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