Check in the pristine copy of ICU 4.6...

icu46/source/i18n/vtzone.cpp

+/*
+*******************************************************************************
+* Copyright (C) 2007-2010, International Business Machines Corporation and
+* others. All Rights Reserved.
+*******************************************************************************
+*/
+
+#include <typeinfo>  // 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 "uhash.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) == 0) {
+            // only support YEARLY frequency type
+            if (value.compare(ICAL_YEARLY) == 0) {
+                yearly = TRUE;
+            } else {
+                goto rruleParseError;
+            }
+        } else if (attr.compare(ICAL_UNTIL) == 0) {
+            // ISO8601 UTC format, for example, "20060315T020000Z"
+            until = parseDateTimeString(value, 0, status);
+            if (U_FAILURE(status)) {
+                goto rruleParseError;
+            }
+        } else if (attr.compare(ICAL_BYMONTH) == 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) == 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) == 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, 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, 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(uhash_deleteUnicodeString, 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(uhash_deleteUnicodeString, 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(uhash_deleteUnicodeString, 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)) {
+                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)) {
+                        vtzlines->addElement(new UnicodeString(line), status);
+                        if (U_FAILURE(status)) {
+                            goto cleanupVtzlines;
+                        }
+                        success = TRUE;
+                        break;
+                    }
+                } else {
+                    if (line.startsWith(ICAL_BEGIN_VTIMEZONE)) {
+                        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(uhash_deleteUnicodeString, 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) == 0
+                && value.compare(ICAL_VTIMEZONE) == 0) {
+                state = VTZ;
+            }
+            break;
+
+        case VTZ:
+            if (name.compare(ICAL_TZID) == 0) {
+                tzid = value;
+            } else if (name.compare(ICAL_TZURL) == 0) {
+                tzurl = value;
+            } else if (name.compare(ICAL_LASTMOD) == 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) == 0) {
+                UBool isDST = (value.compare(ICAL_DAYLIGHT) == 0);
+                if (value.compare(ICAL_STANDARD) == 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) == 0) {
+                break;
+            }
+            break;
+        case TZI:
+            if (name.compare(ICAL_DTSTART) == 0) {
+                dtstart = value;
+            } else if (name.compare(ICAL_TZNAME) == 0) {
+                zonename = value;
+            } else if (name.compare(ICAL_TZOFFSETFROM) == 0) {
+                from = value;
+            } else if (name.compare(ICAL_TZOFFSETTO) == 0) {
+                to = value;
+            } else if (name.compare(ICAL_RDATE) == 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) == 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) == 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,
+                        1,
+                        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)
+                && 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)
+                && 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(uhash_deleteUnicodeString, 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(uhash_deleteUnicodeString, 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);
+        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(uhash_deleteUnicodeString, 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);
+            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;
+                        }
+                        writeFinalRule(w, TRUE, finalDstRule,
+                                dstFromOffset - dstFromDSTSavings, dstFromDSTSavings, dstStartTime, 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;
+                        }
+                        writeFinalRule(w, FALSE, finalStdRule,
+                                stdFromOffset - stdFromDSTSavings, stdFromDSTSavings, stdStartTime, 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