The Tor Browser: intl/icu/source/i18n/vtzone.cpp@fc2d59ddac77 (annotated)

intl/icu/source/i18n/vtzone.cpp@fc2d59ddac77 (annotated)

intl/icu/source/i18n/vtzone.cpp

Wed, 31 Dec 2014 07:22:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:22:50 +0100
branch: TOR_BUG_3246
changeset 4: fc2d59ddac77
permissions: -rw-r--r--

Correct previous dual key logic pending first delivery installment.

 /*
 *******************************************************************************
 * Copyright (C) 2007-2013, International Business Machines Corporation and
 * others. All Rights Reserved.
 *******************************************************************************
 */
 #include "utypeinfo.h"  // for 'typeid' to work
 #include "unicode/utypes.h"
 #if !UCONFIG_NO_FORMATTING
 #include "unicode/vtzone.h"
 #include "unicode/rbtz.h"
 #include "unicode/ucal.h"
 #include "unicode/ures.h"
 #include "cmemory.h"
 #include "uvector.h"
 #include "gregoimp.h"
 #include "uassert.h"
 U_NAMESPACE_BEGIN
 // This is the deleter that will be use to remove TimeZoneRule
 U_CDECL_BEGIN
 static void U_CALLCONV
 deleteTimeZoneRule(void* obj) {
     delete (TimeZoneRule*) obj;
 }
 U_CDECL_END
 // Smybol characters used by RFC2445 VTIMEZONE
 static const UChar COLON = 0x3A; /* : */
 static const UChar SEMICOLON = 0x3B; /* ; */
 static const UChar EQUALS_SIGN = 0x3D; /* = */
 static const UChar COMMA = 0x2C; /* , */
 static const UChar PLUS = 0x2B; /* + */
 static const UChar MINUS = 0x2D; /* - */
 // RFC2445 VTIMEZONE tokens
 static const UChar ICAL_BEGIN_VTIMEZONE[] = {0x42, 0x45, 0x47, 0x49, 0x4E, 0x3A, 0x56, 0x54, 0x49, 0x4D, 0x45, 0x5A, 0x4F, 0x4E, 0x45, 0}; /* "BEGIN:VTIMEZONE" */
 static const UChar ICAL_END_VTIMEZONE[] = {0x45, 0x4E, 0x44, 0x3A, 0x56, 0x54, 0x49, 0x4D, 0x45, 0x5A, 0x4F, 0x4E, 0x45, 0}; /* "END:VTIMEZONE" */
 static const UChar ICAL_BEGIN[] = {0x42, 0x45, 0x47, 0x49, 0x4E, 0}; /* "BEGIN" */
 static const UChar ICAL_END[] = {0x45, 0x4E, 0x44, 0}; /* "END" */
 static const UChar ICAL_VTIMEZONE[] = {0x56, 0x54, 0x49, 0x4D, 0x45, 0x5A, 0x4F, 0x4E, 0x45, 0}; /* "VTIMEZONE" */
 static const UChar ICAL_TZID[] = {0x54, 0x5A, 0x49, 0x44, 0}; /* "TZID" */
 static const UChar ICAL_STANDARD[] = {0x53, 0x54, 0x41, 0x4E, 0x44, 0x41, 0x52, 0x44, 0}; /* "STANDARD" */
 static const UChar ICAL_DAYLIGHT[] = {0x44, 0x41, 0x59, 0x4C, 0x49, 0x47, 0x48, 0x54, 0}; /* "DAYLIGHT" */
 static const UChar ICAL_DTSTART[] = {0x44, 0x54, 0x53, 0x54, 0x41, 0x52, 0x54, 0}; /* "DTSTART" */
 static const UChar ICAL_TZOFFSETFROM[] = {0x54, 0x5A, 0x4F, 0x46, 0x46, 0x53, 0x45, 0x54, 0x46, 0x52, 0x4F, 0x4D, 0}; /* "TZOFFSETFROM" */
 static const UChar ICAL_TZOFFSETTO[] = {0x54, 0x5A, 0x4F, 0x46, 0x46, 0x53, 0x45, 0x54, 0x54, 0x4F, 0}; /* "TZOFFSETTO" */
 static const UChar ICAL_RDATE[] = {0x52, 0x44, 0x41, 0x54, 0x45, 0}; /* "RDATE" */
 static const UChar ICAL_RRULE[] = {0x52, 0x52, 0x55, 0x4C, 0x45, 0}; /* "RRULE" */
 static const UChar ICAL_TZNAME[] = {0x54, 0x5A, 0x4E, 0x41, 0x4D, 0x45, 0}; /* "TZNAME" */
 static const UChar ICAL_TZURL[] = {0x54, 0x5A, 0x55, 0x52, 0x4C, 0}; /* "TZURL" */
 static const UChar ICAL_LASTMOD[] = {0x4C, 0x41, 0x53, 0x54, 0x2D, 0x4D, 0x4F, 0x44, 0x49, 0x46, 0x49, 0x45, 0x44, 0}; /* "LAST-MODIFIED" */
 static const UChar ICAL_FREQ[] = {0x46, 0x52, 0x45, 0x51, 0}; /* "FREQ" */
 static const UChar ICAL_UNTIL[] = {0x55, 0x4E, 0x54, 0x49, 0x4C, 0}; /* "UNTIL" */
 static const UChar ICAL_YEARLY[] = {0x59, 0x45, 0x41, 0x52, 0x4C, 0x59, 0}; /* "YEARLY" */
 static const UChar ICAL_BYMONTH[] = {0x42, 0x59, 0x4D, 0x4F, 0x4E, 0x54, 0x48, 0}; /* "BYMONTH" */
 static const UChar ICAL_BYDAY[] = {0x42, 0x59, 0x44, 0x41, 0x59, 0}; /* "BYDAY" */
 static const UChar ICAL_BYMONTHDAY[] = {0x42, 0x59, 0x4D, 0x4F, 0x4E, 0x54, 0x48, 0x44, 0x41, 0x59, 0}; /* "BYMONTHDAY" */
 static const UChar ICAL_NEWLINE[] = {0x0D, 0x0A, 0}; /* CRLF */
 static const UChar ICAL_DOW_NAMES[7][3] = {
     {0x53, 0x55, 0}, /* "SU" */
     {0x4D, 0x4F, 0}, /* "MO" */
     {0x54, 0x55, 0}, /* "TU" */
     {0x57, 0x45, 0}, /* "WE" */
     {0x54, 0x48, 0}, /* "TH" */
     {0x46, 0x52, 0}, /* "FR" */
     {0x53, 0x41, 0}  /* "SA" */};
 // Month length for non-leap year
 static const int32_t MONTHLENGTH[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 // ICU custom property
 static const UChar ICU_TZINFO_PROP[] = {0x58, 0x2D, 0x54, 0x5A, 0x49, 0x4E, 0x46, 0x4F, 0x3A, 0}; /* "X-TZINFO:" */
 static const UChar ICU_TZINFO_PARTIAL[] = {0x2F, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6C, 0x40, 0}; /* "/Partial@" */
 static const UChar ICU_TZINFO_SIMPLE[] = {0x2F, 0x53, 0x69, 0x6D, 0x70, 0x6C, 0x65, 0x40, 0}; /* "/Simple@" */
 /*
  * Simple fixed digit ASCII number to integer converter
  */
 static int32_t parseAsciiDigits(const UnicodeString& str, int32_t start, int32_t length, UErrorCode& status) {
     if (U_FAILURE(status)) {
         return 0;
     }
     if (length <= 0 || str.length() < start || (start + length) > str.length()) {
         status = U_INVALID_FORMAT_ERROR;
         return 0;
     }
     int32_t sign = 1;
     if (str.charAt(start) == PLUS) {
         start++;
         length--;
     } else if (str.charAt(start) == MINUS) {
         sign = -1;
         start++;
         length--;
     }
     int32_t num = 0;
     for (int32_t i = 0; i < length; i++) {
         int32_t digit = str.charAt(start + i) - 0x0030;
         if (digit < 0 || digit > 9) {
             status = U_INVALID_FORMAT_ERROR;
             return 0;
         }
         num = 10 * num + digit;
     }
     return sign * num;
 }
 static UnicodeString& appendAsciiDigits(int32_t number, uint8_t length, UnicodeString& str) {
     UBool negative = FALSE;
     int32_t digits[10]; // max int32_t is 10 decimal digits
     int32_t i;
     if (number < 0) {
         negative = TRUE;
         number *= -1;
     }
     length = length > 10 ? 10 : length;
     if (length == 0) {
         // variable length
         i = 0;
         do {
             digits[i++] = number % 10;
             number /= 10;
         } while (number != 0);
         length = i;
     } else {
         // fixed digits
         for (i = 0; i < length; i++) {
            digits[i] = number % 10;
            number /= 10;
         }
     }
     if (negative) {
         str.append(MINUS);
     }
     for (i = length - 1; i >= 0; i--) {
         str.append((UChar)(digits[i] + 0x0030));
     }
     return str;
 }
 static UnicodeString& appendMillis(UDate date, UnicodeString& str) {
     UBool negative = FALSE;
     int32_t digits[20]; // max int64_t is 20 decimal digits
     int32_t i;
     int64_t number;
     if (date < MIN_MILLIS) {
         number = (int64_t)MIN_MILLIS;
     } else if (date > MAX_MILLIS) {
         number = (int64_t)MAX_MILLIS;
     } else {
         number = (int64_t)date;
     }
     if (number < 0) {
         negative = TRUE;
         number *= -1;
     }
     i = 0;
     do {
         digits[i++] = (int32_t)(number % 10);
         number /= 10;
     } while (number != 0);
     if (negative) {
         str.append(MINUS);
     }
     i--;
     while (i >= 0) {
         str.append((UChar)(digits[i--] + 0x0030));
     }
     return str;
 }
 /*
  * Convert date/time to RFC2445 Date-Time form #1 DATE WITH LOCAL TIME
  */
 static UnicodeString& getDateTimeString(UDate time, UnicodeString& str) {
     int32_t year, month, dom, dow, doy, mid;
     Grego::timeToFields(time, year, month, dom, dow, doy, mid);
     str.remove();
     appendAsciiDigits(year, 4, str);
     appendAsciiDigits(month + 1, 2, str);
     appendAsciiDigits(dom, 2, str);
     str.append((UChar)0x0054 /*'T'*/);
     int32_t t = mid;
     int32_t hour = t / U_MILLIS_PER_HOUR;
     t %= U_MILLIS_PER_HOUR;
     int32_t min = t / U_MILLIS_PER_MINUTE;
     t %= U_MILLIS_PER_MINUTE;
     int32_t sec = t / U_MILLIS_PER_SECOND;
     appendAsciiDigits(hour, 2, str);
     appendAsciiDigits(min, 2, str);
     appendAsciiDigits(sec, 2, str);
     return str;
 }
 /*
  * Convert date/time to RFC2445 Date-Time form #2 DATE WITH UTC TIME
  */
 static UnicodeString& getUTCDateTimeString(UDate time, UnicodeString& str) {
     getDateTimeString(time, str);
     str.append((UChar)0x005A /*'Z'*/);
     return str;
 }
 /*
  * Parse RFC2445 Date-Time form #1 DATE WITH LOCAL TIME and
  * #2 DATE WITH UTC TIME
  */
 static UDate parseDateTimeString(const UnicodeString& str, int32_t offset, UErrorCode& status) {
     if (U_FAILURE(status)) {
         return 0.0;
     }
     int32_t year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0;
     UBool isUTC = FALSE;
     UBool isValid = FALSE;
     do {
         int length = str.length();
         if (length != 15 && length != 16) {
             // FORM#1 15 characters, such as "20060317T142115"
             // FORM#2 16 characters, such as "20060317T142115Z"
             break;
         }
         if (str.charAt(8) != 0x0054) {
             // charcter "T" must be used for separating date and time
             break;
         }
         if (length == 16) {
             if (str.charAt(15) != 0x005A) {
                 // invalid format
                 break;
             }
             isUTC = TRUE;
         }
         year = parseAsciiDigits(str, 0, 4, status);
         month = parseAsciiDigits(str, 4, 2, status) - 1;  // 0-based
         day = parseAsciiDigits(str, 6, 2, status);
         hour = parseAsciiDigits(str, 9, 2, status);
         min = parseAsciiDigits(str, 11, 2, status);
         sec = parseAsciiDigits(str, 13, 2, status);
         if (U_FAILURE(status)) {
             break;
         }
         // check valid range
         int32_t maxDayOfMonth = Grego::monthLength(year, month);
         if (year < 0 || month < 0 || month > 11 || day < 1 || day > maxDayOfMonth ||
                 hour < 0 || hour >= 24 || min < 0 || min >= 60 || sec < 0 || sec >= 60) {
             break;
         }
         isValid = TRUE;
     } while(false);
     if (!isValid) {
         status = U_INVALID_FORMAT_ERROR;
         return 0.0;
     }
     // Calculate the time
     UDate time = Grego::fieldsToDay(year, month, day) * U_MILLIS_PER_DAY;
     time += (hour * U_MILLIS_PER_HOUR + min * U_MILLIS_PER_MINUTE + sec * U_MILLIS_PER_SECOND);
     if (!isUTC) {
         time -= offset;
     }
     return time;
 }
 /*
  * Convert RFC2445 utc-offset string to milliseconds
  */
 static int32_t offsetStrToMillis(const UnicodeString& str, UErrorCode& status) {
     if (U_FAILURE(status)) {
         return 0;
     }
     UBool isValid = FALSE;
     int32_t sign = 0, hour = 0, min = 0, sec = 0;
     do {
         int length = str.length();
         if (length != 5 && length != 7) {
             // utf-offset must be 5 or 7 characters
             break;
         }
         // sign
         UChar s = str.charAt(0);
         if (s == PLUS) {
             sign = 1;
         } else if (s == MINUS) {
             sign = -1;
         } else {
             // utf-offset must start with "+" or "-"
             break;
         }
         hour = parseAsciiDigits(str, 1, 2, status);
         min = parseAsciiDigits(str, 3, 2, status);
         if (length == 7) {
             sec = parseAsciiDigits(str, 5, 2, status);
         }
         if (U_FAILURE(status)) {
             break;
         }
         isValid = true;
     } while(false);
     if (!isValid) {
         status = U_INVALID_FORMAT_ERROR;
         return 0;
     }
     int32_t millis = sign * ((hour * 60 + min) * 60 + sec) * 1000;
     return millis;
 }
 /*
  * Convert milliseconds to RFC2445 utc-offset string
  */
 static void millisToOffset(int32_t millis, UnicodeString& str) {
     str.remove();
     if (millis >= 0) {
         str.append(PLUS);
     } else {
         str.append(MINUS);
         millis = -millis;
     }
     int32_t hour, min, sec;
     int32_t t = millis / 1000;
     sec = t % 60;
     t = (t - sec) / 60;
     min = t % 60;
     hour = t / 60;
     appendAsciiDigits(hour, 2, str);
     appendAsciiDigits(min, 2, str);
     appendAsciiDigits(sec, 2, str);
 }
 /*
  * Create a default TZNAME from TZID
  */
 static void getDefaultTZName(const UnicodeString tzid, UBool isDST, UnicodeString& zonename) {
     zonename = tzid;
     if (isDST) {
         zonename += UNICODE_STRING_SIMPLE("(DST)");
     } else {
         zonename += UNICODE_STRING_SIMPLE("(STD)");
     }
 }
 /*
  * Parse individual RRULE
  *
  * On return -
  *
  * month    calculated by BYMONTH-1, or -1 when not found
  * dow      day of week in BYDAY, or 0 when not found
  * wim      day of week ordinal number in BYDAY, or 0 when not found
  * dom      an array of day of month
  * domCount number of availble days in dom (domCount is specifying the size of dom on input)
  * until    time defined by UNTIL attribute or MIN_MILLIS if not available
  */
 static void parseRRULE(const UnicodeString& rrule, int32_t& month, int32_t& dow, int32_t& wim,
                        int32_t* dom, int32_t& domCount, UDate& until, UErrorCode& status) {
     if (U_FAILURE(status)) {
         return;
     }
     int32_t numDom = 0;
     month = -1;
     dow = 0;
     wim = 0;
     until = MIN_MILLIS;
     UBool yearly = FALSE;
     //UBool parseError = FALSE;
     int32_t prop_start = 0;
     int32_t prop_end;
     UnicodeString prop, attr, value;
     UBool nextProp = TRUE;
     while (nextProp) {
         prop_end = rrule.indexOf(SEMICOLON, prop_start);
         if (prop_end == -1) {
             prop.setTo(rrule, prop_start);
             nextProp = FALSE;
         } else {
             prop.setTo(rrule, prop_start, prop_end - prop_start);
             prop_start = prop_end + 1;
         }
         int32_t eql = prop.indexOf(EQUALS_SIGN);
         if (eql != -1) {
             attr.setTo(prop, 0, eql);
             value.setTo(prop, eql + 1);
         } else {
             goto rruleParseError;
         }
         if (attr.compare(ICAL_FREQ, -1) == 0) {
             // only support YEARLY frequency type
             if (value.compare(ICAL_YEARLY, -1) == 0) {
                 yearly = TRUE;
             } else {
                 goto rruleParseError;
             }
         } else if (attr.compare(ICAL_UNTIL, -1) == 0) {
             // ISO8601 UTC format, for example, "20060315T020000Z"
             until = parseDateTimeString(value, 0, status);
             if (U_FAILURE(status)) {
                 goto rruleParseError;
             }
         } else if (attr.compare(ICAL_BYMONTH, -1) == 0) {
             // Note: BYMONTH may contain multiple months, but only single month make sense for
             // VTIMEZONE property.
             if (value.length() > 2) {
                 goto rruleParseError;
             }
             month = parseAsciiDigits(value, 0, value.length(), status) - 1;
             if (U_FAILURE(status) || month < 0 || month >= 12) {
                 goto rruleParseError;
             }
         } else if (attr.compare(ICAL_BYDAY, -1) == 0) {
             // Note: BYDAY may contain multiple day of week separated by comma.  It is unlikely used for
             // VTIMEZONE property.  We do not support the case.
             // 2-letter format is used just for representing a day of week, for example, "SU" for Sunday
             // 3 or 4-letter format is used for represeinging Nth day of week, for example, "-1SA" for last Saturday
             int32_t length = value.length();
             if (length < 2 || length > 4) {
                 goto rruleParseError;
             }
             if (length > 2) {
                 // Nth day of week
                 int32_t sign = 1;
                 if (value.charAt(0) == PLUS) {
                     sign = 1;
                 } else if (value.charAt(0) == MINUS) {
                     sign = -1;
                 } else if (length == 4) {
                     goto rruleParseError;
                 }
                 int32_t n = parseAsciiDigits(value, length - 3, 1, status);
                 if (U_FAILURE(status) || n == 0 || n > 4) {
                     goto rruleParseError;
                 }
                 wim = n * sign;
                 value.remove(0, length - 2);
             }
             int32_t wday;
             for (wday = 0; wday < 7; wday++) {
                 if (value.compare(ICAL_DOW_NAMES[wday], 2) == 0) {
                     break;
                 }
             }
             if (wday < 7) {
                 // Sunday(1) - Saturday(7)
                 dow = wday + 1;
             } else {
                 goto rruleParseError;
             }
         } else if (attr.compare(ICAL_BYMONTHDAY, -1) == 0) {
             // Note: BYMONTHDAY may contain multiple days delimitted by comma
             //
             // A value of BYMONTHDAY could be negative, for example, -1 means
             // the last day in a month
             int32_t dom_idx = 0;
             int32_t dom_start = 0;
             int32_t dom_end;
             UBool nextDOM = TRUE;
             while (nextDOM) {
                 dom_end = value.indexOf(COMMA, dom_start);
                 if (dom_end == -1) {
                     dom_end = value.length();
                     nextDOM = FALSE;
                 }
                 if (dom_idx < domCount) {
                     dom[dom_idx] = parseAsciiDigits(value, dom_start, dom_end - dom_start, status);
                     if (U_FAILURE(status)) {
                         goto rruleParseError;
                     }
                     dom_idx++;
                 } else {
                     status = U_BUFFER_OVERFLOW_ERROR;
                     goto rruleParseError;
                 }
                 dom_start = dom_end + 1;
             }
             numDom = dom_idx;
         }
     }
     if (!yearly) {
         // FREQ=YEARLY must be set
         goto rruleParseError;
     }
     // Set actual number of parsed DOM (ICAL_BYMONTHDAY)
     domCount = numDom;
     return;
 rruleParseError:
     if (U_SUCCESS(status)) {
         // Set error status
         status = U_INVALID_FORMAT_ERROR;
     }
 }
 static TimeZoneRule* createRuleByRRULE(const UnicodeString& zonename, int rawOffset, int dstSavings, UDate start,
                                        UVector* dates, int fromOffset, UErrorCode& status) {
     if (U_FAILURE(status)) {
         return NULL;
     }
     if (dates == NULL || dates->size() == 0) {
         status = U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
     }
     int32_t i, j;
     DateTimeRule *adtr = NULL;
     // Parse the first rule
     UnicodeString rrule = *((UnicodeString*)dates->elementAt(0));
     int32_t month, dayOfWeek, nthDayOfWeek, dayOfMonth = 0;
     int32_t days[7];
     int32_t daysCount = sizeof(days)/sizeof(days[0]);
     UDate until;
     parseRRULE(rrule, month, dayOfWeek, nthDayOfWeek, days, daysCount, until, status);
     if (U_FAILURE(status)) {
         return NULL;
     }
     if (dates->size() == 1) {
         // No more rules
         if (daysCount > 1) {
             // Multiple BYMONTHDAY values
             if (daysCount != 7 || month == -1 || dayOfWeek == 0) {
                 // Only support the rule using 7 continuous days
                 // BYMONTH and BYDAY must be set at the same time
                 goto unsupportedRRule;
             }
             int32_t firstDay = 31; // max possible number of dates in a month
             for (i = 0; i < 7; i++) {
                 // Resolve negative day numbers.  A negative day number should
                 // not be used in February, but if we see such case, we use 28
                 // as the base.
                 if (days[i] < 0) {
                     days[i] = MONTHLENGTH[month] + days[i] + 1;
                 }
                 if (days[i] < firstDay) {
                     firstDay = days[i];
                 }
             }
             // Make sure days are continuous
             for (i = 1; i < 7; i++) {
                 UBool found = FALSE;
                 for (j = 0; j < 7; j++) {
                     if (days[j] == firstDay + i) {
                         found = TRUE;
                         break;
                     }
                 }
                 if (!found) {
                     // days are not continuous
                     goto unsupportedRRule;
                 }
             }
             // Use DOW_GEQ_DOM rule with firstDay as the start date
             dayOfMonth = firstDay;
         }
     } else {
         // Check if BYMONTH + BYMONTHDAY + BYDAY rule with multiple RRULE lines.
         // Otherwise, not supported.
         if (month == -1 || dayOfWeek == 0 || daysCount == 0) {
             // This is not the case
             goto unsupportedRRule;
         }
         // Parse the rest of rules if number of rules is not exceeding 7.
         // We can only support 7 continuous days starting from a day of month.
         if (dates->size() > 7) {
             goto unsupportedRRule;
         }
         // Note: To check valid date range across multiple rule is a little
         // bit complicated.  For now, this code is not doing strict range
         // checking across month boundary
         int32_t earliestMonth = month;
         int32_t earliestDay = 31;
         for (i = 0; i < daysCount; i++) {
             int32_t dom = days[i];
             dom = dom > 0 ? dom : MONTHLENGTH[month] + dom + 1;
             earliestDay = dom < earliestDay ? dom : earliestDay;
         }
         int32_t anotherMonth = -1;
         for (i = 1; i < dates->size(); i++) {
             rrule = *((UnicodeString*)dates->elementAt(i));
             UDate tmp_until;
             int32_t tmp_month, tmp_dayOfWeek, tmp_nthDayOfWeek;
             int32_t tmp_days[7];
             int32_t tmp_daysCount = sizeof(tmp_days)/sizeof(tmp_days[0]);
             parseRRULE(rrule, tmp_month, tmp_dayOfWeek, tmp_nthDayOfWeek, tmp_days, tmp_daysCount, tmp_until, status);
             if (U_FAILURE(status)) {
                 return NULL;
             }
             // If UNTIL is newer than previous one, use the one
             if (tmp_until > until) {
                 until = tmp_until;
             }
             // Check if BYMONTH + BYMONTHDAY + BYDAY rule
             if (tmp_month == -1 || tmp_dayOfWeek == 0 || tmp_daysCount == 0) {
                 goto unsupportedRRule;
             }
             // Count number of BYMONTHDAY
             if (daysCount + tmp_daysCount > 7) {
                 // We cannot support BYMONTHDAY more than 7
                 goto unsupportedRRule;
             }
             // Check if the same BYDAY is used.  Otherwise, we cannot
             // support the rule
             if (tmp_dayOfWeek != dayOfWeek) {
                 goto unsupportedRRule;
             }
             // Check if the month is same or right next to the primary month
             if (tmp_month != month) {
                 if (anotherMonth == -1) {
                     int32_t diff = tmp_month - month;
                     if (diff == -11 || diff == -1) {
                         // Previous month
                         anotherMonth = tmp_month;
                         earliestMonth = anotherMonth;
                         // Reset earliest day
                         earliestDay = 31;
                     } else if (diff == 11 || diff == 1) {
                         // Next month
                         anotherMonth = tmp_month;
                     } else {
                         // The day range cannot exceed more than 2 months
                         goto unsupportedRRule;
                     }
                 } else if (tmp_month != month && tmp_month != anotherMonth) {
                     // The day range cannot exceed more than 2 months
                     goto unsupportedRRule;
                 }
             }
             // If ealier month, go through days to find the earliest day
             if (tmp_month == earliestMonth) {
                 for (j = 0; j < tmp_daysCount; j++) {
                     tmp_days[j] = tmp_days[j] > 0 ? tmp_days[j] : MONTHLENGTH[tmp_month] + tmp_days[j] + 1;
                     earliestDay = tmp_days[j] < earliestDay ? tmp_days[j] : earliestDay;
                 }
             }
             daysCount += tmp_daysCount;
         }
         if (daysCount != 7) {
             // Number of BYMONTHDAY entries must be 7
             goto unsupportedRRule;
         }
         month = earliestMonth;
         dayOfMonth = earliestDay;
     }
     // Calculate start/end year and missing fields
     int32_t startYear, startMonth, startDOM, startDOW, startDOY, startMID;
     Grego::timeToFields(start + fromOffset, startYear, startMonth, startDOM,
         startDOW, startDOY, startMID);
     if (month == -1) {
         // If BYMONTH is not set, use the month of DTSTART
         month = startMonth;
     }
     if (dayOfWeek == 0 && nthDayOfWeek == 0 && dayOfMonth == 0) {
         // If only YEARLY is set, use the day of DTSTART as BYMONTHDAY
         dayOfMonth = startDOM;
     }
     int32_t endYear;
     if (until != MIN_MILLIS) {
         int32_t endMonth, endDOM, endDOW, endDOY, endMID;
         Grego::timeToFields(until, endYear, endMonth, endDOM, endDOW, endDOY, endMID);
     } else {
         endYear = AnnualTimeZoneRule::MAX_YEAR;
     }
     // Create the AnnualDateTimeRule
     if (dayOfWeek == 0 && nthDayOfWeek == 0 && dayOfMonth != 0) {
         // Day in month rule, for example, 15th day in the month
         adtr = new DateTimeRule(month, dayOfMonth, startMID, DateTimeRule::WALL_TIME);
     } else if (dayOfWeek != 0 && nthDayOfWeek != 0 && dayOfMonth == 0) {
         // Nth day of week rule, for example, last Sunday
         adtr = new DateTimeRule(month, nthDayOfWeek, dayOfWeek, startMID, DateTimeRule::WALL_TIME);
     } else if (dayOfWeek != 0 && nthDayOfWeek == 0 && dayOfMonth != 0) {
         // First day of week after day of month rule, for example,
         // first Sunday after 15th day in the month
         adtr = new DateTimeRule(month, dayOfMonth, dayOfWeek, TRUE, startMID, DateTimeRule::WALL_TIME);
     }
     if (adtr == NULL) {
         goto unsupportedRRule;
     }
     return new AnnualTimeZoneRule(zonename, rawOffset, dstSavings, adtr, startYear, endYear);
 unsupportedRRule:
     status = U_INVALID_STATE_ERROR;
     return NULL;
 }
 /*
  * Create a TimeZoneRule by the RDATE definition
  */
 static TimeZoneRule* createRuleByRDATE(const UnicodeString& zonename, int32_t rawOffset, int32_t dstSavings,
                                        UDate start, UVector* dates, int32_t fromOffset, UErrorCode& status) {
     if (U_FAILURE(status)) {
         return NULL;
     }
     TimeArrayTimeZoneRule *retVal = NULL;
     if (dates == NULL || dates->size() == 0) {
         // When no RDATE line is provided, use start (DTSTART)
         // as the transition time
         retVal = new TimeArrayTimeZoneRule(zonename, rawOffset, dstSavings,
             &start, 1, DateTimeRule::UTC_TIME);
     } else {
         // Create an array of transition times
         int32_t size = dates->size();
         UDate* times = (UDate*)uprv_malloc(sizeof(UDate) * size);
         if (times == NULL) {
             status = U_MEMORY_ALLOCATION_ERROR;
             return NULL;
         }
         for (int32_t i = 0; i < size; i++) {
             UnicodeString *datestr = (UnicodeString*)dates->elementAt(i);
             times[i] = parseDateTimeString(*datestr, fromOffset, status);
             if (U_FAILURE(status)) {
                 uprv_free(times);
                 return NULL;
             }
         }
         retVal = new TimeArrayTimeZoneRule(zonename, rawOffset, dstSavings,
             times, size, DateTimeRule::UTC_TIME);
         uprv_free(times);
     }
     return retVal;
 }
 /*
  * Check if the DOW rule specified by month, weekInMonth and dayOfWeek is equivalent
  * to the DateTimerule.
  */
 static UBool isEquivalentDateRule(int32_t month, int32_t weekInMonth, int32_t dayOfWeek, const DateTimeRule *dtrule) {
     if (month != dtrule->getRuleMonth() || dayOfWeek != dtrule->getRuleDayOfWeek()) {
         return FALSE;
     }
     if (dtrule->getTimeRuleType() != DateTimeRule::WALL_TIME) {
         // Do not try to do more intelligent comparison for now.
         return FALSE;
     }
     if (dtrule->getDateRuleType() == DateTimeRule::DOW
             && dtrule->getRuleWeekInMonth() == weekInMonth) {
         return TRUE;
     }
     int32_t ruleDOM = dtrule->getRuleDayOfMonth();
     if (dtrule->getDateRuleType() == DateTimeRule::DOW_GEQ_DOM) {
         if (ruleDOM%7 == 1 && (ruleDOM + 6)/7 == weekInMonth) {
             return TRUE;
         }
         if (month != UCAL_FEBRUARY && (MONTHLENGTH[month] - ruleDOM)%7 == 6
                 && weekInMonth == -1*((MONTHLENGTH[month]-ruleDOM+1)/7)) {
             return TRUE;
         }
     }
     if (dtrule->getDateRuleType() == DateTimeRule::DOW_LEQ_DOM) {
         if (ruleDOM%7 == 0 && ruleDOM/7 == weekInMonth) {
             return TRUE;
         }
         if (month != UCAL_FEBRUARY && (MONTHLENGTH[month] - ruleDOM)%7 == 0
                 && weekInMonth == -1*((MONTHLENGTH[month] - ruleDOM)/7 + 1)) {
             return TRUE;
         }
     }
     return FALSE;
 }
 /*
  * Convert the rule to its equivalent rule using WALL_TIME mode.
  * This function returns NULL when the specified DateTimeRule is already
  * using WALL_TIME mode.
  */
 static DateTimeRule* toWallTimeRule(const DateTimeRule* rule, int32_t rawOffset, int32_t dstSavings) {
     if (rule->getTimeRuleType() == DateTimeRule::WALL_TIME) {
         return NULL;
     }
     int32_t wallt = rule->getRuleMillisInDay();
     if (rule->getTimeRuleType() == DateTimeRule::UTC_TIME) {
         wallt += (rawOffset + dstSavings);
     } else if (rule->getTimeRuleType() == DateTimeRule::STANDARD_TIME) {
         wallt += dstSavings;
     }
     int32_t month = -1, dom = 0, dow = 0;
     DateTimeRule::DateRuleType dtype;
     int32_t dshift = 0;
     if (wallt < 0) {
         dshift = -1;
         wallt += U_MILLIS_PER_DAY;
     } else if (wallt >= U_MILLIS_PER_DAY) {
         dshift = 1;
         wallt -= U_MILLIS_PER_DAY;
     }
     month = rule->getRuleMonth();
     dom = rule->getRuleDayOfMonth();
     dow = rule->getRuleDayOfWeek();
     dtype = rule->getDateRuleType();
     if (dshift != 0) {
         if (dtype == DateTimeRule::DOW) {
             // Convert to DOW_GEW_DOM or DOW_LEQ_DOM rule first
             int32_t wim = rule->getRuleWeekInMonth();
             if (wim > 0) {
                 dtype = DateTimeRule::DOW_GEQ_DOM;
                 dom = 7 * (wim - 1) + 1;
             } else {
                 dtype = DateTimeRule::DOW_LEQ_DOM;
                 dom = MONTHLENGTH[month] + 7 * (wim + 1);
             }
         }
         // Shift one day before or after
         dom += dshift;
         if (dom == 0) {
             month--;
             month = month < UCAL_JANUARY ? UCAL_DECEMBER : month;
             dom = MONTHLENGTH[month];
         } else if (dom > MONTHLENGTH[month]) {
             month++;
             month = month > UCAL_DECEMBER ? UCAL_JANUARY : month;
             dom = 1;
         }
         if (dtype != DateTimeRule::DOM) {
             // Adjust day of week
             dow += dshift;
             if (dow < UCAL_SUNDAY) {
                 dow = UCAL_SATURDAY;
             } else if (dow > UCAL_SATURDAY) {
                 dow = UCAL_SUNDAY;
             }
         }
     }
     // Create a new rule
     DateTimeRule *modifiedRule;
     if (dtype == DateTimeRule::DOM) {
         modifiedRule = new DateTimeRule(month, dom, wallt, DateTimeRule::WALL_TIME);
     } else {
         modifiedRule = new DateTimeRule(month, dom, dow,
             (dtype == DateTimeRule::DOW_GEQ_DOM), wallt, DateTimeRule::WALL_TIME);
     }
     return modifiedRule;
 }
 /*
  * Minumum implementations of stream writer/reader, writing/reading
  * UnicodeString.  For now, we do not want to introduce the dependency
  * on the ICU I/O stream in this module.  But we want to keep the code
  * equivalent to the ICU4J implementation, which utilizes java.io.Writer/
  * Reader.
  */
 class VTZWriter {
 public:
     VTZWriter(UnicodeString& out);
     ~VTZWriter();
     void write(const UnicodeString& str);
     void write(UChar ch);
     void write(const UChar* str);
     //void write(const UChar* str, int32_t length);
 private:
     UnicodeString* out;
 };
 VTZWriter::VTZWriter(UnicodeString& output) {
     out = &output;
 }
 VTZWriter::~VTZWriter() {
 }
 void
 VTZWriter::write(const UnicodeString& str) {
     out->append(str);
 }
 void
 VTZWriter::write(UChar ch) {
     out->append(ch);
 }
 void
 VTZWriter::write(const UChar* str) {
     out->append(str, -1);
 }
 /*
 void
 VTZWriter::write(const UChar* str, int32_t length) {
     out->append(str, length);
 }
 */
 class VTZReader {
 public:
     VTZReader(const UnicodeString& input);
     ~VTZReader();
     UChar read(void);
 private:
     const UnicodeString* in;
     int32_t index;
 };
 VTZReader::VTZReader(const UnicodeString& input) {
     in = &input;
     index = 0;
 }
 VTZReader::~VTZReader() {
 }
 UChar
 VTZReader::read(void) {
     UChar ch = 0xFFFF;
     if (index < in->length()) {
         ch = in->charAt(index);
     }
     index++;
     return ch;
 }
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(VTimeZone)
 VTimeZone::VTimeZone()
 :   BasicTimeZone(), tz(NULL), vtzlines(NULL),
     lastmod(MAX_MILLIS) {
 }
 VTimeZone::VTimeZone(const VTimeZone& source)
 :   BasicTimeZone(source), tz(NULL), vtzlines(NULL),
     tzurl(source.tzurl), lastmod(source.lastmod),
     olsonzid(source.olsonzid), icutzver(source.icutzver) {
     if (source.tz != NULL) {
         tz = (BasicTimeZone*)source.tz->clone();
     }
     if (source.vtzlines != NULL) {
         UErrorCode status = U_ZERO_ERROR;
         int32_t size = source.vtzlines->size();
         vtzlines = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, size, status);
         if (U_SUCCESS(status)) {
             for (int32_t i = 0; i < size; i++) {
                 UnicodeString *line = (UnicodeString*)source.vtzlines->elementAt(i);
                 vtzlines->addElement(line->clone(), status);
                 if (U_FAILURE(status)) {
                     break;
                 }
             }
         }
         if (U_FAILURE(status) && vtzlines != NULL) {
             delete vtzlines;
         }
     }
 }
 VTimeZone::~VTimeZone() {
     if (tz != NULL) {
         delete tz;
     }
     if (vtzlines != NULL) {
         delete vtzlines;
     }
 }
 VTimeZone&
 VTimeZone::operator=(const VTimeZone& right) {
     if (this == &right) {
         return *this;
     }
     if (*this != right) {
         BasicTimeZone::operator=(right);
         if (tz != NULL) {
             delete tz;
             tz = NULL;
         }
         if (right.tz != NULL) {
             tz = (BasicTimeZone*)right.tz->clone();
         }
         if (vtzlines != NULL) {
             delete vtzlines;
         }
         if (right.vtzlines != NULL) {
             UErrorCode status = U_ZERO_ERROR;
             int32_t size = right.vtzlines->size();
             vtzlines = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, size, status);
             if (U_SUCCESS(status)) {
                 for (int32_t i = 0; i < size; i++) {
                     UnicodeString *line = (UnicodeString*)right.vtzlines->elementAt(i);
                     vtzlines->addElement(line->clone(), status);
                     if (U_FAILURE(status)) {
                         break;
                     }
                 }
             }
             if (U_FAILURE(status) && vtzlines != NULL) {
                 delete vtzlines;
                 vtzlines = NULL;
             }
         }
         tzurl = right.tzurl;
         lastmod = right.lastmod;
         olsonzid = right.olsonzid;
         icutzver = right.icutzver;
     }
     return *this;
 }
 UBool
 VTimeZone::operator==(const TimeZone& that) const {
     if (this == &that) {
         return TRUE;
     }
     if (typeid(*this) != typeid(that) || !BasicTimeZone::operator==(that)) {
         return FALSE;
     }
     VTimeZone *vtz = (VTimeZone*)&that;
     if (*tz == *(vtz->tz)
         && tzurl == vtz->tzurl
         && lastmod == vtz->lastmod
         /* && olsonzid = that.olsonzid */
         /* && icutzver = that.icutzver */) {
         return TRUE;
     }
     return FALSE;
 }
 UBool
 VTimeZone::operator!=(const TimeZone& that) const {
     return !operator==(that);
 }
 VTimeZone*
 VTimeZone::createVTimeZoneByID(const UnicodeString& ID) {
     VTimeZone *vtz = new VTimeZone();
     vtz->tz = (BasicTimeZone*)TimeZone::createTimeZone(ID);
     vtz->tz->getID(vtz->olsonzid);
     // Set ICU tzdata version
     UErrorCode status = U_ZERO_ERROR;
     UResourceBundle *bundle = NULL;
     const UChar* versionStr = NULL;
     int32_t len = 0;
     bundle = ures_openDirect(NULL, "zoneinfo64", &status);
     versionStr = ures_getStringByKey(bundle, "TZVersion", &len, &status);
     if (U_SUCCESS(status)) {
         vtz->icutzver.setTo(versionStr, len);
     }
     ures_close(bundle);
     return vtz;
 }
 VTimeZone*
 VTimeZone::createVTimeZoneFromBasicTimeZone(const BasicTimeZone& basic_time_zone, UErrorCode &status) {
     if (U_FAILURE(status)) {
         return NULL;
     }
     VTimeZone *vtz = new VTimeZone();
     if (vtz == NULL) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return NULL;
     }
     vtz->tz = (BasicTimeZone *)basic_time_zone.clone();
     if (vtz->tz == NULL) {
         status = U_MEMORY_ALLOCATION_ERROR;
         delete vtz;
         return NULL;
     }
     vtz->tz->getID(vtz->olsonzid);
     // Set ICU tzdata version
     UResourceBundle *bundle = NULL;
     const UChar* versionStr = NULL;
     int32_t len = 0;
     bundle = ures_openDirect(NULL, "zoneinfo64", &status);
     versionStr = ures_getStringByKey(bundle, "TZVersion", &len, &status);
     if (U_SUCCESS(status)) {
         vtz->icutzver.setTo(versionStr, len);
     }
     ures_close(bundle);
     return vtz;
 }
 VTimeZone*
 VTimeZone::createVTimeZone(const UnicodeString& vtzdata, UErrorCode& status) {
     if (U_FAILURE(status)) {
         return NULL;
     }
     VTZReader reader(vtzdata);
     VTimeZone *vtz = new VTimeZone();
     vtz->load(reader, status);
     if (U_FAILURE(status)) {
         delete vtz;
         return NULL;
     }
     return vtz;
 }
 UBool
 VTimeZone::getTZURL(UnicodeString& url) const {
     if (tzurl.length() > 0) {
         url = tzurl;
         return TRUE;
     }
     return FALSE;
 }
 void
 VTimeZone::setTZURL(const UnicodeString& url) {
     tzurl = url;
 }
 UBool
 VTimeZone::getLastModified(UDate& lastModified) const {
     if (lastmod != MAX_MILLIS) {
         lastModified = lastmod;
         return TRUE;
     }
     return FALSE;
 }
 void
 VTimeZone::setLastModified(UDate lastModified) {
     lastmod = lastModified;
 }
 void
 VTimeZone::write(UnicodeString& result, UErrorCode& status) const {
     result.remove();
     VTZWriter writer(result);
     write(writer, status);
 }
 void
 VTimeZone::write(UDate start, UnicodeString& result, UErrorCode& status) const {
     result.remove();
     VTZWriter writer(result);
     write(start, writer, status);
 }
 void
 VTimeZone::writeSimple(UDate time, UnicodeString& result, UErrorCode& status) const {
     result.remove();
     VTZWriter writer(result);
     writeSimple(time, writer, status);
 }
 TimeZone*
 VTimeZone::clone(void) const {
     return new VTimeZone(*this);
 }
 int32_t
 VTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
                      uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const {
     return tz->getOffset(era, year, month, day, dayOfWeek, millis, status);
 }
 int32_t
 VTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
                      uint8_t dayOfWeek, int32_t millis,
                      int32_t monthLength, UErrorCode& status) const {
     return tz->getOffset(era, year, month, day, dayOfWeek, millis, monthLength, status);
 }
 void
 VTimeZone::getOffset(UDate date, UBool local, int32_t& rawOffset,
                      int32_t& dstOffset, UErrorCode& status) const {
     return tz->getOffset(date, local, rawOffset, dstOffset, status);
 }
 void
 VTimeZone::setRawOffset(int32_t offsetMillis) {
     tz->setRawOffset(offsetMillis);
 }
 int32_t
 VTimeZone::getRawOffset(void) const {
     return tz->getRawOffset();
 }
 UBool
 VTimeZone::useDaylightTime(void) const {
     return tz->useDaylightTime();
 }
 UBool
 VTimeZone::inDaylightTime(UDate date, UErrorCode& status) const {
     return tz->inDaylightTime(date, status);
 }
 UBool
 VTimeZone::hasSameRules(const TimeZone& other) const {
     return tz->hasSameRules(other);
 }
 UBool
 VTimeZone::getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {
     return tz->getNextTransition(base, inclusive, result);
 }
 UBool
 VTimeZone::getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {
     return tz->getPreviousTransition(base, inclusive, result);
 }
 int32_t
 VTimeZone::countTransitionRules(UErrorCode& status) const {
     return tz->countTransitionRules(status);
 }
 void
 VTimeZone::getTimeZoneRules(const InitialTimeZoneRule*& initial,
                             const TimeZoneRule* trsrules[], int32_t& trscount,
                             UErrorCode& status) const {
     tz->getTimeZoneRules(initial, trsrules, trscount, status);
 }
 void
 VTimeZone::load(VTZReader& reader, UErrorCode& status) {
     vtzlines = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, DEFAULT_VTIMEZONE_LINES, status);
     if (U_FAILURE(status)) {
         return;
     }
     UBool eol = FALSE;
     UBool start = FALSE;
     UBool success = FALSE;
     UnicodeString line;
     while (TRUE) {
         UChar ch = reader.read();
         if (ch == 0xFFFF) {
             // end of file
             if (start && line.startsWith(ICAL_END_VTIMEZONE, -1)) {
                 vtzlines->addElement(new UnicodeString(line), status);
                 if (U_FAILURE(status)) {
                     goto cleanupVtzlines;
                 }
                 success = TRUE;
             }
             break;
         }
         if (ch == 0x000D) {
             // CR, must be followed by LF according to the definition in RFC2445
             continue;
         }
         if (eol) {
             if (ch != 0x0009 && ch != 0x0020) {
                 // NOT followed by TAB/SP -> new line
                 if (start) {
                     if (line.length() > 0) {
                         vtzlines->addElement(new UnicodeString(line), status);
                         if (U_FAILURE(status)) {
                             goto cleanupVtzlines;
                         }
                     }
                 }
                 line.remove();
                 if (ch != 0x000A) {
                     line.append(ch);
                 }
             }
             eol = FALSE;
         } else {
             if (ch == 0x000A) {
                 // LF
                 eol = TRUE;
                 if (start) {
                     if (line.startsWith(ICAL_END_VTIMEZONE, -1)) {
                         vtzlines->addElement(new UnicodeString(line), status);
                         if (U_FAILURE(status)) {
                             goto cleanupVtzlines;
                         }
                         success = TRUE;
                         break;
                     }
                 } else {
                     if (line.startsWith(ICAL_BEGIN_VTIMEZONE, -1)) {
                         vtzlines->addElement(new UnicodeString(line), status);
                         if (U_FAILURE(status)) {
                             goto cleanupVtzlines;
                         }
                         line.remove();
                         start = TRUE;
                         eol = FALSE;
                     }
                 }
             } else {
                 line.append(ch);
             }
         }
     }
     if (!success) {
         if (U_SUCCESS(status)) {
             status = U_INVALID_STATE_ERROR;
         }
         goto cleanupVtzlines;
     }
     parse(status);
     return;
 cleanupVtzlines:
     delete vtzlines;
     vtzlines = NULL;
 }
 // parser state
 #define INI 0   // Initial state
 #define VTZ 1   // In VTIMEZONE
 #define TZI 2   // In STANDARD or DAYLIGHT
 #define DEF_DSTSAVINGS (60*60*1000)
 #define DEF_TZSTARTTIME (0.0)
 void
 VTimeZone::parse(UErrorCode& status) {
     if (U_FAILURE(status)) {
         return;
     }
     if (vtzlines == NULL || vtzlines->size() == 0) {
         status = U_INVALID_STATE_ERROR;
         return;
     }
     InitialTimeZoneRule *initialRule = NULL;
     RuleBasedTimeZone *rbtz = NULL;
     // timezone ID
     UnicodeString tzid;
     int32_t state = INI;
     int32_t n = 0;
     UBool dst = FALSE;      // current zone type
     UnicodeString from;     // current zone from offset
     UnicodeString to;       // current zone offset
     UnicodeString zonename;   // current zone name
     UnicodeString dtstart;  // current zone starts
     UBool isRRULE = FALSE;  // true if the rule is described by RRULE
     int32_t initialRawOffset = 0;   // initial offset
     int32_t initialDSTSavings = 0;  // initial offset
     UDate firstStart = MAX_MILLIS;  // the earliest rule start time
     UnicodeString name;     // RFC2445 prop name
     UnicodeString value;    // RFC2445 prop value
     UVector *dates = NULL;  // list of RDATE or RRULE strings
     UVector *rules = NULL;  // list of TimeZoneRule instances
     int32_t finalRuleIdx = -1;
     int32_t finalRuleCount = 0;
     rules = new UVector(status);
     if (U_FAILURE(status)) {
         goto cleanupParse;
     }
      // Set the deleter to remove TimeZoneRule vectors to avoid memory leaks due to unowned TimeZoneRules.
     rules->setDeleter(deleteTimeZoneRule);
     dates = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status);
     if (U_FAILURE(status)) {
         goto cleanupParse;
     }
     if (rules == NULL || dates == NULL) {
         status = U_MEMORY_ALLOCATION_ERROR;
         goto cleanupParse;
     }
     for (n = 0; n < vtzlines->size(); n++) {
         UnicodeString *line = (UnicodeString*)vtzlines->elementAt(n);
         int32_t valueSep = line->indexOf(COLON);
         if (valueSep < 0) {
             continue;
         }
         name.setTo(*line, 0, valueSep);
         value.setTo(*line, valueSep + 1);
         switch (state) {
         case INI:
             if (name.compare(ICAL_BEGIN, -1) == 0
                 && value.compare(ICAL_VTIMEZONE, -1) == 0) {
                 state = VTZ;
             }
             break;
         case VTZ:
             if (name.compare(ICAL_TZID, -1) == 0) {
                 tzid = value;
             } else if (name.compare(ICAL_TZURL, -1) == 0) {
                 tzurl = value;
             } else if (name.compare(ICAL_LASTMOD, -1) == 0) {
                 // Always in 'Z' format, so the offset argument for the parse method
                 // can be any value.
                 lastmod = parseDateTimeString(value, 0, status);
                 if (U_FAILURE(status)) {
                     goto cleanupParse;
                 }
             } else if (name.compare(ICAL_BEGIN, -1) == 0) {
                 UBool isDST = (value.compare(ICAL_DAYLIGHT, -1) == 0);
                 if (value.compare(ICAL_STANDARD, -1) == 0 || isDST) {
                     // tzid must be ready at this point
                     if (tzid.length() == 0) {
                         goto cleanupParse;
                     }
                     // initialize current zone properties
                     if (dates->size() != 0) {
                         dates->removeAllElements();
                     }
                     isRRULE = FALSE;
                     from.remove();
                     to.remove();
                     zonename.remove();
                     dst = isDST;
                     state = TZI;
                 } else {
                     // BEGIN property other than STANDARD/DAYLIGHT
                     // must not be there.
                     goto cleanupParse;
                 }
             } else if (name.compare(ICAL_END, -1) == 0) {
                 break;
             }
             break;
         case TZI:
             if (name.compare(ICAL_DTSTART, -1) == 0) {
                 dtstart = value;
             } else if (name.compare(ICAL_TZNAME, -1) == 0) {
                 zonename = value;
             } else if (name.compare(ICAL_TZOFFSETFROM, -1) == 0) {
                 from = value;
             } else if (name.compare(ICAL_TZOFFSETTO, -1) == 0) {
                 to = value;
             } else if (name.compare(ICAL_RDATE, -1) == 0) {
                 // RDATE mixed with RRULE is not supported
                 if (isRRULE) {
                     goto cleanupParse;
                 }
                 // RDATE value may contain multiple date delimited
                 // by comma
                 UBool nextDate = TRUE;
                 int32_t dstart = 0;
                 UnicodeString *dstr;
                 while (nextDate) {
                     int32_t dend = value.indexOf(COMMA, dstart);
                     if (dend == -1) {
                         dstr = new UnicodeString(value, dstart);
                         nextDate = FALSE;
                     } else {
                         dstr = new UnicodeString(value, dstart, dend - dstart);
                     }
                     dates->addElement(dstr, status);
                     if (U_FAILURE(status)) {
                         goto cleanupParse;
                     }
                     dstart = dend + 1;
                 }
             } else if (name.compare(ICAL_RRULE, -1) == 0) {
                 // RRULE mixed with RDATE is not supported
                 if (!isRRULE && dates->size() != 0) {
                     goto cleanupParse;
                 }
                 isRRULE = true;
                 dates->addElement(new UnicodeString(value), status);
                 if (U_FAILURE(status)) {
                     goto cleanupParse;
                 }
             } else if (name.compare(ICAL_END, -1) == 0) {
                 // Mandatory properties
                 if (dtstart.length() == 0 || from.length() == 0 || to.length() == 0) {
                     goto cleanupParse;
                 }
                 // if zonename is not available, create one from tzid
                 if (zonename.length() == 0) {
                     getDefaultTZName(tzid, dst, zonename);
                 }
                 // create a time zone rule
                 TimeZoneRule *rule = NULL;
                 int32_t fromOffset = 0;
                 int32_t toOffset = 0;
                 int32_t rawOffset = 0;
                 int32_t dstSavings = 0;
                 UDate start = 0;
                 // Parse TZOFFSETFROM/TZOFFSETTO
                 fromOffset = offsetStrToMillis(from, status);
                 toOffset = offsetStrToMillis(to, status);
                 if (U_FAILURE(status)) {
                     goto cleanupParse;
                 }
                 if (dst) {
                     // If daylight, use the previous offset as rawoffset if positive
                     if (toOffset - fromOffset > 0) {
                         rawOffset = fromOffset;
                         dstSavings = toOffset - fromOffset;
                     } else {
                         // This is rare case..  just use 1 hour DST savings
                         rawOffset = toOffset - DEF_DSTSAVINGS;
                         dstSavings = DEF_DSTSAVINGS;
                     }
                 } else {
                     rawOffset = toOffset;
                     dstSavings = 0;
                 }
                 // start time
                 start = parseDateTimeString(dtstart, fromOffset, status);
                 if (U_FAILURE(status)) {
                     goto cleanupParse;
                 }
                 // Create the rule
                 UDate actualStart = MAX_MILLIS;
                 if (isRRULE) {
                     rule = createRuleByRRULE(zonename, rawOffset, dstSavings, start, dates, fromOffset, status);
                 } else {
                     rule = createRuleByRDATE(zonename, rawOffset, dstSavings, start, dates, fromOffset, status);
                 }
                 if (U_FAILURE(status) || rule == NULL) {
                     goto cleanupParse;
                 } else {
                     UBool startAvail = rule->getFirstStart(fromOffset, 0, actualStart);
                     if (startAvail && actualStart < firstStart) {
                         // save from offset information for the earliest rule
                         firstStart = actualStart;
                         // If this is STD, assume the time before this transtion
                         // is DST when the difference is 1 hour.  This might not be
                         // accurate, but VTIMEZONE data does not have such info.
                         if (dstSavings > 0) {
                             initialRawOffset = fromOffset;
                             initialDSTSavings = 0;
                         } else {
                             if (fromOffset - toOffset == DEF_DSTSAVINGS) {
                                 initialRawOffset = fromOffset - DEF_DSTSAVINGS;
                                 initialDSTSavings = DEF_DSTSAVINGS;
                             } else {
                                 initialRawOffset = fromOffset;
                                 initialDSTSavings = 0;
                             }
                         }
                     }
                 }
                 rules->addElement(rule, status);
                 if (U_FAILURE(status)) {
                     goto cleanupParse;
                 }
                 state = VTZ;
             }
             break;
         }
     }
     // Must have at least one rule
     if (rules->size() == 0) {
         goto cleanupParse;
     }
     // Create a initial rule
     getDefaultTZName(tzid, FALSE, zonename);
     initialRule = new InitialTimeZoneRule(zonename,
         initialRawOffset, initialDSTSavings);
     if (initialRule == NULL) {
         status = U_MEMORY_ALLOCATION_ERROR;
         goto cleanupParse;
     }
     // Finally, create the RuleBasedTimeZone
     rbtz = new RuleBasedTimeZone(tzid, initialRule);
     if (rbtz == NULL) {
         status = U_MEMORY_ALLOCATION_ERROR;
         goto cleanupParse;
     }
     initialRule = NULL; // already adopted by RBTZ, no need to delete
     for (n = 0; n < rules->size(); n++) {
         TimeZoneRule *r = (TimeZoneRule*)rules->elementAt(n);
         AnnualTimeZoneRule *atzrule = dynamic_cast<AnnualTimeZoneRule *>(r);
         if (atzrule != NULL) {
             if (atzrule->getEndYear() == AnnualTimeZoneRule::MAX_YEAR) {
                 finalRuleCount++;
                 finalRuleIdx = n;
             }
         }
     }
     if (finalRuleCount > 2) {
         // Too many final rules
         status = U_ILLEGAL_ARGUMENT_ERROR;
         goto cleanupParse;
     }
     if (finalRuleCount == 1) {
         if (rules->size() == 1) {
             // Only one final rule, only governs the initial rule,
             // which is already initialized, thus, we do not need to
             // add this transition rule
             rules->removeAllElements();
         } else {
             // Normalize the final rule
             AnnualTimeZoneRule *finalRule = (AnnualTimeZoneRule*)rules->elementAt(finalRuleIdx);
             int32_t tmpRaw = finalRule->getRawOffset();
             int32_t tmpDST = finalRule->getDSTSavings();
             // Find the last non-final rule
             UDate finalStart, start;
             finalRule->getFirstStart(initialRawOffset, initialDSTSavings, finalStart);
             start = finalStart;
             for (n = 0; n < rules->size(); n++) {
                 if (finalRuleIdx == n) {
                     continue;
                 }
                 TimeZoneRule *r = (TimeZoneRule*)rules->elementAt(n);
                 UDate lastStart;
                 r->getFinalStart(tmpRaw, tmpDST, lastStart);
                 if (lastStart > start) {
                     finalRule->getNextStart(lastStart,
                         r->getRawOffset(),
                         r->getDSTSavings(),
                         FALSE,
                         start);
                 }
             }
             TimeZoneRule *newRule;
             UnicodeString tznam;
             if (start == finalStart) {
                 // Transform this into a single transition
                 newRule = new TimeArrayTimeZoneRule(
                         finalRule->getName(tznam),
                         finalRule->getRawOffset(),
                         finalRule->getDSTSavings(),
                         &finalStart,
 ,
                         DateTimeRule::UTC_TIME);
             } else {
                 // Update the end year
                 int32_t y, m, d, dow, doy, mid;
                 Grego::timeToFields(start, y, m, d, dow, doy, mid);
                 newRule = new AnnualTimeZoneRule(
                         finalRule->getName(tznam),
                         finalRule->getRawOffset(),
                         finalRule->getDSTSavings(),
                         *(finalRule->getRule()),
                         finalRule->getStartYear(),
                         y);
             }
             if (newRule == NULL) {
                 status = U_MEMORY_ALLOCATION_ERROR;
                 goto cleanupParse;
             }
             rules->removeElementAt(finalRuleIdx);
             rules->addElement(newRule, status);
             if (U_FAILURE(status)) {
                 delete newRule;
                 goto cleanupParse;
             }
         }
     }
     while (!rules->isEmpty()) {
         TimeZoneRule *tzr = (TimeZoneRule*)rules->orphanElementAt(0);
         rbtz->addTransitionRule(tzr, status);
         if (U_FAILURE(status)) {
             goto cleanupParse;
         }
     }
     rbtz->complete(status);
     if (U_FAILURE(status)) {
         goto cleanupParse;
     }
     delete rules;
     delete dates;
     tz = rbtz;
     setID(tzid);
     return;
 cleanupParse:
     if (rules != NULL) {
         while (!rules->isEmpty()) {
             TimeZoneRule *r = (TimeZoneRule*)rules->orphanElementAt(0);
             delete r;
         }
         delete rules;
     }
     if (dates != NULL) {
         delete dates;
     }
     if (initialRule != NULL) {
         delete initialRule;
     }
     if (rbtz != NULL) {
         delete rbtz;
     }
     return;
 }
 void
 VTimeZone::write(VTZWriter& writer, UErrorCode& status) const {
     if (vtzlines != NULL) {
         for (int32_t i = 0; i < vtzlines->size(); i++) {
             UnicodeString *line = (UnicodeString*)vtzlines->elementAt(i);
             if (line->startsWith(ICAL_TZURL, -1)
                 && line->charAt(u_strlen(ICAL_TZURL)) == COLON) {
                 writer.write(ICAL_TZURL);
                 writer.write(COLON);
                 writer.write(tzurl);
                 writer.write(ICAL_NEWLINE);
             } else if (line->startsWith(ICAL_LASTMOD, -1)
                 && line->charAt(u_strlen(ICAL_LASTMOD)) == COLON) {
                 UnicodeString utcString;
                 writer.write(ICAL_LASTMOD);
                 writer.write(COLON);
                 writer.write(getUTCDateTimeString(lastmod, utcString));
                 writer.write(ICAL_NEWLINE);
             } else {
                 writer.write(*line);
                 writer.write(ICAL_NEWLINE);
             }
         }
     } else {
         UVector *customProps = NULL;
         if (olsonzid.length() > 0 && icutzver.length() > 0) {
             customProps = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status);
             if (U_FAILURE(status)) {
                 return;
             }
             UnicodeString *icutzprop = new UnicodeString(ICU_TZINFO_PROP);
             icutzprop->append(olsonzid);
             icutzprop->append((UChar)0x005B/*'['*/);
             icutzprop->append(icutzver);
             icutzprop->append((UChar)0x005D/*']'*/);
             customProps->addElement(icutzprop, status);
             if (U_FAILURE(status)) {
                 delete icutzprop;
                 delete customProps;
                 return;
             }
         }
         writeZone(writer, *tz, customProps, status);
         delete customProps;
     }
 }
 void
 VTimeZone::write(UDate start, VTZWriter& writer, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     InitialTimeZoneRule *initial = NULL;
     UVector *transitionRules = NULL;
     UVector customProps(uprv_deleteUObject, uhash_compareUnicodeString, status);
     UnicodeString tzid;
     // Extract rules applicable to dates after the start time
     getTimeZoneRulesAfter(start, initial, transitionRules, status);
     if (U_FAILURE(status)) {
         return;
     }
     // Create a RuleBasedTimeZone with the subset rule
     getID(tzid);
     RuleBasedTimeZone rbtz(tzid, initial);
     if (transitionRules != NULL) {
         while (!transitionRules->isEmpty()) {
             TimeZoneRule *tr = (TimeZoneRule*)transitionRules->orphanElementAt(0);
             rbtz.addTransitionRule(tr, status);
             if (U_FAILURE(status)) {
                 goto cleanupWritePartial;
             }
         }
         delete transitionRules;
         transitionRules = NULL;
     }
     rbtz.complete(status);
     if (U_FAILURE(status)) {
         goto cleanupWritePartial;
     }
     if (olsonzid.length() > 0 && icutzver.length() > 0) {
         UnicodeString *icutzprop = new UnicodeString(ICU_TZINFO_PROP);
         icutzprop->append(olsonzid);
         icutzprop->append((UChar)0x005B/*'['*/);
         icutzprop->append(icutzver);
         icutzprop->append(ICU_TZINFO_PARTIAL, -1);
         appendMillis(start, *icutzprop);
         icutzprop->append((UChar)0x005D/*']'*/);
         customProps.addElement(icutzprop, status);
         if (U_FAILURE(status)) {
             delete icutzprop;
             goto cleanupWritePartial;
         }
     }
     writeZone(writer, rbtz, &customProps, status);
     return;
 cleanupWritePartial:
     if (initial != NULL) {
         delete initial;
     }
     if (transitionRules != NULL) {
         while (!transitionRules->isEmpty()) {
             TimeZoneRule *tr = (TimeZoneRule*)transitionRules->orphanElementAt(0);
             delete tr;
         }
         delete transitionRules;
     }
 }
 void
 VTimeZone::writeSimple(UDate time, VTZWriter& writer, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     UVector customProps(uprv_deleteUObject, uhash_compareUnicodeString, status);
     UnicodeString tzid;
     // Extract simple rules
     InitialTimeZoneRule *initial = NULL;
     AnnualTimeZoneRule *std = NULL, *dst = NULL;
     getSimpleRulesNear(time, initial, std, dst, status);
     if (U_SUCCESS(status)) {
         // Create a RuleBasedTimeZone with the subset rule
         getID(tzid);
         RuleBasedTimeZone rbtz(tzid, initial);
         if (std != NULL && dst != NULL) {
             rbtz.addTransitionRule(std, status);
             rbtz.addTransitionRule(dst, status);
         }
         if (U_FAILURE(status)) {
             goto cleanupWriteSimple;
         }
         if (olsonzid.length() > 0 && icutzver.length() > 0) {
             UnicodeString *icutzprop = new UnicodeString(ICU_TZINFO_PROP);
             icutzprop->append(olsonzid);
             icutzprop->append((UChar)0x005B/*'['*/);
             icutzprop->append(icutzver);
             icutzprop->append(ICU_TZINFO_SIMPLE, -1);
             appendMillis(time, *icutzprop);
             icutzprop->append((UChar)0x005D/*']'*/);
             customProps.addElement(icutzprop, status);
             if (U_FAILURE(status)) {
                 delete icutzprop;
                 goto cleanupWriteSimple;
             }
         }
         writeZone(writer, rbtz, &customProps, status);
     }
     return;
 cleanupWriteSimple:
     if (initial != NULL) {
         delete initial;
     }
     if (std != NULL) {
         delete std;
     }
     if (dst != NULL) {
         delete dst;
     }
 }
 void
 VTimeZone::writeZone(VTZWriter& w, BasicTimeZone& basictz,
                      UVector* customProps, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     writeHeaders(w, status);
     if (U_FAILURE(status)) {
         return;
     }
     if (customProps != NULL) {
         for (int32_t i = 0; i < customProps->size(); i++) {
             UnicodeString *custprop = (UnicodeString*)customProps->elementAt(i);
             w.write(*custprop);
             w.write(ICAL_NEWLINE);
         }
     }
     UDate t = MIN_MILLIS;
     UnicodeString dstName;
     int32_t dstFromOffset = 0;
     int32_t dstFromDSTSavings = 0;
     int32_t dstToOffset = 0;
     int32_t dstStartYear = 0;
     int32_t dstMonth = 0;
     int32_t dstDayOfWeek = 0;
     int32_t dstWeekInMonth = 0;
     int32_t dstMillisInDay = 0;
     UDate dstStartTime = 0.0;
     UDate dstUntilTime = 0.0;
     int32_t dstCount = 0;
     AnnualTimeZoneRule *finalDstRule = NULL;
     UnicodeString stdName;
     int32_t stdFromOffset = 0;
     int32_t stdFromDSTSavings = 0;
     int32_t stdToOffset = 0;
     int32_t stdStartYear = 0;
     int32_t stdMonth = 0;
     int32_t stdDayOfWeek = 0;
     int32_t stdWeekInMonth = 0;
     int32_t stdMillisInDay = 0;
     UDate stdStartTime = 0.0;
     UDate stdUntilTime = 0.0;
     int32_t stdCount = 0;
     AnnualTimeZoneRule *finalStdRule = NULL;
     int32_t year, month, dom, dow, doy, mid;
     UBool hasTransitions = FALSE;
     TimeZoneTransition tzt;
     UBool tztAvail;
     UnicodeString name;
     UBool isDst;
     // Going through all transitions
     while (TRUE) {
         tztAvail = basictz.getNextTransition(t, FALSE, tzt);
         if (!tztAvail) {
             break;
         }
         hasTransitions = TRUE;
         t = tzt.getTime();
         tzt.getTo()->getName(name);
         isDst = (tzt.getTo()->getDSTSavings() != 0);
         int32_t fromOffset = tzt.getFrom()->getRawOffset() + tzt.getFrom()->getDSTSavings();
         int32_t fromDSTSavings = tzt.getFrom()->getDSTSavings();
         int32_t toOffset = tzt.getTo()->getRawOffset() + tzt.getTo()->getDSTSavings();
         Grego::timeToFields(tzt.getTime() + fromOffset, year, month, dom, dow, doy, mid);
         int32_t weekInMonth = Grego::dayOfWeekInMonth(year, month, dom);
         UBool sameRule = FALSE;
         const AnnualTimeZoneRule *atzrule;
         if (isDst) {
             if (finalDstRule == NULL
                 && (atzrule = dynamic_cast<const AnnualTimeZoneRule *>(tzt.getTo())) != NULL
                 && atzrule->getEndYear() == AnnualTimeZoneRule::MAX_YEAR
             ) {
                 finalDstRule = (AnnualTimeZoneRule*)tzt.getTo()->clone();
             }
             if (dstCount > 0) {
                 if (year == dstStartYear + dstCount
                         && name.compare(dstName) == 0
                         && dstFromOffset == fromOffset
                         && dstToOffset == toOffset
                         && dstMonth == month
                         && dstDayOfWeek == dow
                         && dstWeekInMonth == weekInMonth
                         && dstMillisInDay == mid) {
                     // Update until time
                     dstUntilTime = t;
                     dstCount++;
                     sameRule = TRUE;
                 }
                 if (!sameRule) {
                     if (dstCount == 1) {
                         writeZonePropsByTime(w, TRUE, dstName, dstFromOffset, dstToOffset, dstStartTime,
                                 TRUE, status);
                     } else {
                         writeZonePropsByDOW(w, TRUE, dstName, dstFromOffset, dstToOffset,
                                 dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, dstUntilTime, status);
                     }
                     if (U_FAILURE(status)) {
                         goto cleanupWriteZone;
                     }
                 }
             }
             if (!sameRule) {
                 // Reset this DST information
                 dstName = name;
                 dstFromOffset = fromOffset;
                 dstFromDSTSavings = fromDSTSavings;
                 dstToOffset = toOffset;
                 dstStartYear = year;
                 dstMonth = month;
                 dstDayOfWeek = dow;
                 dstWeekInMonth = weekInMonth;
                 dstMillisInDay = mid;
                 dstStartTime = dstUntilTime = t;
                 dstCount = 1;
             }
             if (finalStdRule != NULL && finalDstRule != NULL) {
                 break;
             }
         } else {
             if (finalStdRule == NULL
                 && (atzrule = dynamic_cast<const AnnualTimeZoneRule *>(tzt.getTo())) != NULL
                 && atzrule->getEndYear() == AnnualTimeZoneRule::MAX_YEAR
             ) {
                 finalStdRule = (AnnualTimeZoneRule*)tzt.getTo()->clone();
             }
             if (stdCount > 0) {
                 if (year == stdStartYear + stdCount
                         && name.compare(stdName) == 0
                         && stdFromOffset == fromOffset
                         && stdToOffset == toOffset
                         && stdMonth == month
                         && stdDayOfWeek == dow
                         && stdWeekInMonth == weekInMonth
                         && stdMillisInDay == mid) {
                     // Update until time
                     stdUntilTime = t;
                     stdCount++;
                     sameRule = TRUE;
                 }
                 if (!sameRule) {
                     if (stdCount == 1) {
                         writeZonePropsByTime(w, FALSE, stdName, stdFromOffset, stdToOffset, stdStartTime,
                                 TRUE, status);
                     } else {
                         writeZonePropsByDOW(w, FALSE, stdName, stdFromOffset, stdToOffset,
                                 stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, stdUntilTime, status);
                     }
                     if (U_FAILURE(status)) {
                         goto cleanupWriteZone;
                     }
                 }
             }
             if (!sameRule) {
                 // Reset this STD information
                 stdName = name;
                 stdFromOffset = fromOffset;
                 stdFromDSTSavings = fromDSTSavings;
                 stdToOffset = toOffset;
                 stdStartYear = year;
                 stdMonth = month;
                 stdDayOfWeek = dow;
                 stdWeekInMonth = weekInMonth;
                 stdMillisInDay = mid;
                 stdStartTime = stdUntilTime = t;
                 stdCount = 1;
             }
             if (finalStdRule != NULL && finalDstRule != NULL) {
                 break;
             }
         }
     }
     if (!hasTransitions) {
         // No transition - put a single non transition RDATE
         int32_t raw, dst, offset;
         basictz.getOffset(0.0/*any time*/, FALSE, raw, dst, status);
         if (U_FAILURE(status)) {
             goto cleanupWriteZone;
         }
         offset = raw + dst;
         isDst = (dst != 0);
         UnicodeString tzid;
         basictz.getID(tzid);
         getDefaultTZName(tzid, isDst, name);
         writeZonePropsByTime(w, isDst, name,
                 offset, offset, DEF_TZSTARTTIME - offset, FALSE, status);
         if (U_FAILURE(status)) {
             goto cleanupWriteZone;
         }
     } else {
         if (dstCount > 0) {
             if (finalDstRule == NULL) {
                 if (dstCount == 1) {
                     writeZonePropsByTime(w, TRUE, dstName, dstFromOffset, dstToOffset, dstStartTime,
                             TRUE, status);
                 } else {
                     writeZonePropsByDOW(w, TRUE, dstName, dstFromOffset, dstToOffset,
                             dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, dstUntilTime, status);
                 }
                 if (U_FAILURE(status)) {
                     goto cleanupWriteZone;
                 }
             } else {
                 if (dstCount == 1) {
                     writeFinalRule(w, TRUE, finalDstRule,
                             dstFromOffset - dstFromDSTSavings, dstFromDSTSavings, dstStartTime, status);
                 } else {
                     // Use a single rule if possible
                     if (isEquivalentDateRule(dstMonth, dstWeekInMonth, dstDayOfWeek, finalDstRule->getRule())) {
                         writeZonePropsByDOW(w, TRUE, dstName, dstFromOffset, dstToOffset,
                                 dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, MAX_MILLIS, status);
                     } else {
                         // Not equivalent rule - write out two different rules
                         writeZonePropsByDOW(w, TRUE, dstName, dstFromOffset, dstToOffset,
                                 dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, dstUntilTime, status);
                         if (U_FAILURE(status)) {
                             goto cleanupWriteZone;
                         }
                         UDate nextStart;
                         UBool nextStartAvail = finalDstRule->getNextStart(dstUntilTime, dstFromOffset - dstFromDSTSavings, dstFromDSTSavings, false, nextStart);
                         U_ASSERT(nextStartAvail);
                         if (nextStartAvail) {
                             writeFinalRule(w, TRUE, finalDstRule,
                                     dstFromOffset - dstFromDSTSavings, dstFromDSTSavings, nextStart, status);
                         }
                     }
                 }
                 if (U_FAILURE(status)) {
                     goto cleanupWriteZone;
                 }
             }
         }
         if (stdCount > 0) {
             if (finalStdRule == NULL) {
                 if (stdCount == 1) {
                     writeZonePropsByTime(w, FALSE, stdName, stdFromOffset, stdToOffset, stdStartTime,
                             TRUE, status);
                 } else {
                     writeZonePropsByDOW(w, FALSE, stdName, stdFromOffset, stdToOffset,
                             stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, stdUntilTime, status);
                 }
                 if (U_FAILURE(status)) {
                     goto cleanupWriteZone;
                 }
             } else {
                 if (stdCount == 1) {
                     writeFinalRule(w, FALSE, finalStdRule,
                             stdFromOffset - stdFromDSTSavings, stdFromDSTSavings, stdStartTime, status);
                 } else {
                     // Use a single rule if possible
                     if (isEquivalentDateRule(stdMonth, stdWeekInMonth, stdDayOfWeek, finalStdRule->getRule())) {
                         writeZonePropsByDOW(w, FALSE, stdName, stdFromOffset, stdToOffset,
                                 stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, MAX_MILLIS, status);
                     } else {
                         // Not equivalent rule - write out two different rules
                         writeZonePropsByDOW(w, FALSE, stdName, stdFromOffset, stdToOffset,
                                 stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, stdUntilTime, status);
                         if (U_FAILURE(status)) {
                             goto cleanupWriteZone;
                         }
                         UDate nextStart;
                         UBool nextStartAvail = finalStdRule->getNextStart(stdUntilTime, stdFromOffset - stdFromDSTSavings, stdFromDSTSavings, false, nextStart);
                         U_ASSERT(nextStartAvail);
                         if (nextStartAvail) {
                             writeFinalRule(w, FALSE, finalStdRule,
                                     stdFromOffset - stdFromDSTSavings, stdFromDSTSavings, nextStart, status);
                         }
                     }
                 }
                 if (U_FAILURE(status)) {
                     goto cleanupWriteZone;
                 }
             }
         }
     }
     writeFooter(w, status);
 cleanupWriteZone:
     if (finalStdRule != NULL) {
         delete finalStdRule;
     }
     if (finalDstRule != NULL) {
         delete finalDstRule;
     }
 }
 void
 VTimeZone::writeHeaders(VTZWriter& writer, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     UnicodeString tzid;
     tz->getID(tzid);
     writer.write(ICAL_BEGIN);
     writer.write(COLON);
     writer.write(ICAL_VTIMEZONE);
     writer.write(ICAL_NEWLINE);
     writer.write(ICAL_TZID);
     writer.write(COLON);
     writer.write(tzid);
     writer.write(ICAL_NEWLINE);
     if (tzurl.length() != 0) {
         writer.write(ICAL_TZURL);
         writer.write(COLON);
         writer.write(tzurl);
         writer.write(ICAL_NEWLINE);
     }
     if (lastmod != MAX_MILLIS) {
         UnicodeString lastmodStr;
         writer.write(ICAL_LASTMOD);
         writer.write(COLON);
         writer.write(getUTCDateTimeString(lastmod, lastmodStr));
         writer.write(ICAL_NEWLINE);
     }
 }
 /*
  * Write the closing section of the VTIMEZONE definition block
  */
 void
 VTimeZone::writeFooter(VTZWriter& writer, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     writer.write(ICAL_END);
     writer.write(COLON);
     writer.write(ICAL_VTIMEZONE);
     writer.write(ICAL_NEWLINE);
 }
 /*
  * Write a single start time
  */
 void
 VTimeZone::writeZonePropsByTime(VTZWriter& writer, UBool isDst, const UnicodeString& zonename,
                                 int32_t fromOffset, int32_t toOffset, UDate time, UBool withRDATE,
                                 UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     beginZoneProps(writer, isDst, zonename, fromOffset, toOffset, time, status);
     if (U_FAILURE(status)) {
         return;
     }
     if (withRDATE) {
         writer.write(ICAL_RDATE);
         writer.write(COLON);
         UnicodeString timestr;
         writer.write(getDateTimeString(time + fromOffset, timestr));
         writer.write(ICAL_NEWLINE);
     }
     endZoneProps(writer, isDst, status);
     if (U_FAILURE(status)) {
         return;
     }
 }
 /*
  * Write start times defined by a DOM rule using VTIMEZONE RRULE
  */
 void
 VTimeZone::writeZonePropsByDOM(VTZWriter& writer, UBool isDst, const UnicodeString& zonename,
                                int32_t fromOffset, int32_t toOffset,
                                int32_t month, int32_t dayOfMonth, UDate startTime, UDate untilTime,
                                UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     beginZoneProps(writer, isDst, zonename, fromOffset, toOffset, startTime, status);
     if (U_FAILURE(status)) {
         return;
     }
     beginRRULE(writer, month, status);
     if (U_FAILURE(status)) {
         return;
     }
     writer.write(ICAL_BYMONTHDAY);
     writer.write(EQUALS_SIGN);
     UnicodeString dstr;
     appendAsciiDigits(dayOfMonth, 0, dstr);
     writer.write(dstr);
     if (untilTime != MAX_MILLIS) {
         appendUNTIL(writer, getDateTimeString(untilTime + fromOffset, dstr), status);
         if (U_FAILURE(status)) {
             return;
         }
     }
     writer.write(ICAL_NEWLINE);
     endZoneProps(writer, isDst, status);
 }
 /*
  * Write start times defined by a DOW rule using VTIMEZONE RRULE
  */
 void
 VTimeZone::writeZonePropsByDOW(VTZWriter& writer, UBool isDst, const UnicodeString& zonename,
                                int32_t fromOffset, int32_t toOffset,
                                int32_t month, int32_t weekInMonth, int32_t dayOfWeek,
                                UDate startTime, UDate untilTime, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     beginZoneProps(writer, isDst, zonename, fromOffset, toOffset, startTime, status);
     if (U_FAILURE(status)) {
         return;
     }
     beginRRULE(writer, month, status);
     if (U_FAILURE(status)) {
         return;
     }
     writer.write(ICAL_BYDAY);
     writer.write(EQUALS_SIGN);
     UnicodeString dstr;
     appendAsciiDigits(weekInMonth, 0, dstr);
     writer.write(dstr);    // -4, -3, -2, -1, 1, 2, 3, 4
     writer.write(ICAL_DOW_NAMES[dayOfWeek - 1]);    // SU, MO, TU...
     if (untilTime != MAX_MILLIS) {
         appendUNTIL(writer, getDateTimeString(untilTime + fromOffset, dstr), status);
         if (U_FAILURE(status)) {
             return;
         }
     }
     writer.write(ICAL_NEWLINE);
     endZoneProps(writer, isDst, status);
 }
 /*
  * Write start times defined by a DOW_GEQ_DOM rule using VTIMEZONE RRULE
  */
 void
 VTimeZone::writeZonePropsByDOW_GEQ_DOM(VTZWriter& writer, UBool isDst, const UnicodeString& zonename,
                                        int32_t fromOffset, int32_t toOffset,
                                        int32_t month, int32_t dayOfMonth, int32_t dayOfWeek,
                                        UDate startTime, UDate untilTime, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     // Check if this rule can be converted to DOW rule
     if (dayOfMonth%7 == 1) {
         // Can be represented by DOW rule
         writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset,
                 month, (dayOfMonth + 6)/7, dayOfWeek, startTime, untilTime, status);
         if (U_FAILURE(status)) {
             return;
         }
     } else if (month != UCAL_FEBRUARY && (MONTHLENGTH[month] - dayOfMonth)%7 == 6) {
         // Can be represented by DOW rule with negative week number
         writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset,
                 month, -1*((MONTHLENGTH[month] - dayOfMonth + 1)/7), dayOfWeek, startTime, untilTime, status);
         if (U_FAILURE(status)) {
             return;
         }
     } else {
         // Otherwise, use BYMONTHDAY to include all possible dates
         beginZoneProps(writer, isDst, zonename, fromOffset, toOffset, startTime, status);
         if (U_FAILURE(status)) {
             return;
         }
         // Check if all days are in the same month
         int32_t startDay = dayOfMonth;
         int32_t currentMonthDays = 7;
         if (dayOfMonth <= 0) {
             // The start day is in previous month
             int32_t prevMonthDays = 1 - dayOfMonth;
             currentMonthDays -= prevMonthDays;
             int32_t prevMonth = (month - 1) < 0 ? 11 : month - 1;
             // Note: When a rule is separated into two, UNTIL attribute needs to be
             // calculated for each of them.  For now, we skip this, because we basically use this method
             // only for final rules, which does not have the UNTIL attribute
             writeZonePropsByDOW_GEQ_DOM_sub(writer, prevMonth, -prevMonthDays, dayOfWeek, prevMonthDays,
                 MAX_MILLIS /* Do not use UNTIL */, fromOffset, status);
             if (U_FAILURE(status)) {
                 return;
             }
             // Start from 1 for the rest
             startDay = 1;
         } else if (dayOfMonth + 6 > MONTHLENGTH[month]) {
             // Note: This code does not actually work well in February.  For now, days in month in
             // non-leap year.
             int32_t nextMonthDays = dayOfMonth + 6 - MONTHLENGTH[month];
             currentMonthDays -= nextMonthDays;
             int32_t nextMonth = (month + 1) > 11 ? 0 : month + 1;
             writeZonePropsByDOW_GEQ_DOM_sub(writer, nextMonth, 1, dayOfWeek, nextMonthDays,
                 MAX_MILLIS /* Do not use UNTIL */, fromOffset, status);
             if (U_FAILURE(status)) {
                 return;
             }
         }
         writeZonePropsByDOW_GEQ_DOM_sub(writer, month, startDay, dayOfWeek, currentMonthDays,
             untilTime, fromOffset, status);
         if (U_FAILURE(status)) {
             return;
         }
         endZoneProps(writer, isDst, status);
     }
 }
 /*
  * Called from writeZonePropsByDOW_GEQ_DOM
  */
 void
 VTimeZone::writeZonePropsByDOW_GEQ_DOM_sub(VTZWriter& writer, int32_t month, int32_t dayOfMonth,
                                            int32_t dayOfWeek, int32_t numDays,
                                            UDate untilTime, int32_t fromOffset, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     int32_t startDayNum = dayOfMonth;
     UBool isFeb = (month == UCAL_FEBRUARY);
     if (dayOfMonth < 0 && !isFeb) {
         // Use positive number if possible
         startDayNum = MONTHLENGTH[month] + dayOfMonth + 1;
     }
     beginRRULE(writer, month, status);
     if (U_FAILURE(status)) {
         return;
     }
     writer.write(ICAL_BYDAY);
     writer.write(EQUALS_SIGN);
     writer.write(ICAL_DOW_NAMES[dayOfWeek - 1]);    // SU, MO, TU...
     writer.write(SEMICOLON);
     writer.write(ICAL_BYMONTHDAY);
     writer.write(EQUALS_SIGN);
     UnicodeString dstr;
     appendAsciiDigits(startDayNum, 0, dstr);
     writer.write(dstr);
     for (int32_t i = 1; i < numDays; i++) {
         writer.write(COMMA);
         dstr.remove();
         appendAsciiDigits(startDayNum + i, 0, dstr);
         writer.write(dstr);
     }
     if (untilTime != MAX_MILLIS) {
         appendUNTIL(writer, getDateTimeString(untilTime + fromOffset, dstr), status);
         if (U_FAILURE(status)) {
             return;
         }
     }
     writer.write(ICAL_NEWLINE);
 }
 /*
  * Write start times defined by a DOW_LEQ_DOM rule using VTIMEZONE RRULE
  */
 void
 VTimeZone::writeZonePropsByDOW_LEQ_DOM(VTZWriter& writer, UBool isDst, const UnicodeString& zonename,
                                        int32_t fromOffset, int32_t toOffset,
                                        int32_t month, int32_t dayOfMonth, int32_t dayOfWeek,
                                        UDate startTime, UDate untilTime, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     // Check if this rule can be converted to DOW rule
     if (dayOfMonth%7 == 0) {
         // Can be represented by DOW rule
         writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset,
                 month, dayOfMonth/7, dayOfWeek, startTime, untilTime, status);
     } else if (month != UCAL_FEBRUARY && (MONTHLENGTH[month] - dayOfMonth)%7 == 0){
         // Can be represented by DOW rule with negative week number
         writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset,
                 month, -1*((MONTHLENGTH[month] - dayOfMonth)/7 + 1), dayOfWeek, startTime, untilTime, status);
     } else if (month == UCAL_FEBRUARY && dayOfMonth == 29) {
         // Specical case for February
         writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset,
                 UCAL_FEBRUARY, -1, dayOfWeek, startTime, untilTime, status);
     } else {
         // Otherwise, convert this to DOW_GEQ_DOM rule
         writeZonePropsByDOW_GEQ_DOM(writer, isDst, zonename, fromOffset, toOffset,
                 month, dayOfMonth - 6, dayOfWeek, startTime, untilTime, status);
     }
 }
 /*
  * Write the final time zone rule using RRULE, with no UNTIL attribute
  */
 void
 VTimeZone::writeFinalRule(VTZWriter& writer, UBool isDst, const AnnualTimeZoneRule* rule,
                           int32_t fromRawOffset, int32_t fromDSTSavings,
                           UDate startTime, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     UBool modifiedRule = TRUE;
     const DateTimeRule *dtrule = toWallTimeRule(rule->getRule(), fromRawOffset, fromDSTSavings);
     if (dtrule == NULL) {
         modifiedRule = FALSE;
         dtrule = rule->getRule();
     }
     // If the rule's mills in a day is out of range, adjust start time.
     // Olson tzdata supports 24:00 of a day, but VTIMEZONE does not.
     // See ticket#7008/#7518
     int32_t timeInDay = dtrule->getRuleMillisInDay();
     if (timeInDay < 0) {
         startTime = startTime + (0 - timeInDay);
     } else if (timeInDay >= U_MILLIS_PER_DAY) {
         startTime = startTime - (timeInDay - (U_MILLIS_PER_DAY - 1));
     }
     int32_t toOffset = rule->getRawOffset() + rule->getDSTSavings();
     UnicodeString name;
     rule->getName(name);
     switch (dtrule->getDateRuleType()) {
     case DateTimeRule::DOM:
         writeZonePropsByDOM(writer, isDst, name, fromRawOffset + fromDSTSavings, toOffset,
                 dtrule->getRuleMonth(), dtrule->getRuleDayOfMonth(), startTime, MAX_MILLIS, status);
         break;
     case DateTimeRule::DOW:
         writeZonePropsByDOW(writer, isDst, name, fromRawOffset + fromDSTSavings, toOffset,
                 dtrule->getRuleMonth(), dtrule->getRuleWeekInMonth(), dtrule->getRuleDayOfWeek(), startTime, MAX_MILLIS, status);
         break;
     case DateTimeRule::DOW_GEQ_DOM:
         writeZonePropsByDOW_GEQ_DOM(writer, isDst, name, fromRawOffset + fromDSTSavings, toOffset,
                 dtrule->getRuleMonth(), dtrule->getRuleDayOfMonth(), dtrule->getRuleDayOfWeek(), startTime, MAX_MILLIS, status);
         break;
     case DateTimeRule::DOW_LEQ_DOM:
         writeZonePropsByDOW_LEQ_DOM(writer, isDst, name, fromRawOffset + fromDSTSavings, toOffset,
                 dtrule->getRuleMonth(), dtrule->getRuleDayOfMonth(), dtrule->getRuleDayOfWeek(), startTime, MAX_MILLIS, status);
         break;
     }
     if (modifiedRule) {
         delete dtrule;
     }
 }
 /*
  * Write the opening section of zone properties
  */
 void
 VTimeZone::beginZoneProps(VTZWriter& writer, UBool isDst, const UnicodeString& zonename,
                           int32_t fromOffset, int32_t toOffset, UDate startTime, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     writer.write(ICAL_BEGIN);
     writer.write(COLON);
     if (isDst) {
         writer.write(ICAL_DAYLIGHT);
     } else {
         writer.write(ICAL_STANDARD);
     }
     writer.write(ICAL_NEWLINE);
     UnicodeString dstr;
     // TZOFFSETTO
     writer.write(ICAL_TZOFFSETTO);
     writer.write(COLON);
     millisToOffset(toOffset, dstr);
     writer.write(dstr);
     writer.write(ICAL_NEWLINE);
     // TZOFFSETFROM
     writer.write(ICAL_TZOFFSETFROM);
     writer.write(COLON);
     millisToOffset(fromOffset, dstr);
     writer.write(dstr);
     writer.write(ICAL_NEWLINE);
     // TZNAME
     writer.write(ICAL_TZNAME);
     writer.write(COLON);
     writer.write(zonename);
     writer.write(ICAL_NEWLINE);
     // DTSTART
     writer.write(ICAL_DTSTART);
     writer.write(COLON);
     writer.write(getDateTimeString(startTime + fromOffset, dstr));
     writer.write(ICAL_NEWLINE);
 }
 /*
  * Writes the closing section of zone properties
  */
 void
 VTimeZone::endZoneProps(VTZWriter& writer, UBool isDst, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     // END:STANDARD or END:DAYLIGHT
     writer.write(ICAL_END);
     writer.write(COLON);
     if (isDst) {
         writer.write(ICAL_DAYLIGHT);
     } else {
         writer.write(ICAL_STANDARD);
     }
     writer.write(ICAL_NEWLINE);
 }
 /*
  * Write the beggining part of RRULE line
  */
 void
 VTimeZone::beginRRULE(VTZWriter& writer, int32_t month, UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     UnicodeString dstr;
     writer.write(ICAL_RRULE);
     writer.write(COLON);
     writer.write(ICAL_FREQ);
     writer.write(EQUALS_SIGN);
     writer.write(ICAL_YEARLY);
     writer.write(SEMICOLON);
     writer.write(ICAL_BYMONTH);
     writer.write(EQUALS_SIGN);
     appendAsciiDigits(month + 1, 0, dstr);
     writer.write(dstr);
     writer.write(SEMICOLON);
 }
 /*
  * Append the UNTIL attribute after RRULE line
  */
 void
 VTimeZone::appendUNTIL(VTZWriter& writer, const UnicodeString& until,  UErrorCode& status) const {
     if (U_FAILURE(status)) {
         return;
     }
     if (until.length() > 0) {
         writer.write(SEMICOLON);
         writer.write(ICAL_UNTIL);
         writer.write(EQUALS_SIGN);
         writer.write(until);
     }
 }
 U_NAMESPACE_END
 #endif /* #if !UCONFIG_NO_FORMATTING */
 //eof

The Tor Browser / annotate

intl/icu/source/i18n/vtzone.cpp@fc2d59ddac77 (annotated)

intl/icu/source/i18n/vtzone.cpp