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