]> git.saurik.com Git - apple/icu.git/blob - icuSources/i18n/tzfmt.cpp
projects / apple / icu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ICU-511.34.tar.gz
[apple/icu.git] / icuSources / i18n / tzfmt.cpp
1 /*
2 *******************************************************************************
3 * Copyright (C) 2011-2013, International Business Machines Corporation and *
4 * others. All Rights Reserved. *
5 *******************************************************************************
6 */
7
8 #include "unicode/utypes.h"
9
10 #if !UCONFIG_NO_FORMATTING
11
12 #include "unicode/calendar.h"
13 #include "unicode/tzfmt.h"
14 #include "unicode/numsys.h"
15 #include "unicode/uchar.h"
16 #include "unicode/udat.h"
17 #include "tzgnames.h"
18 #include "cmemory.h"
19 #include "cstring.h"
20 #include "putilimp.h"
21 #include "uassert.h"
22 #include "ucln_in.h"
23 #include "umutex.h"
24 #include "uresimp.h"
25 #include "ureslocs.h"
26 #include "uvector.h"
27 #include "zonemeta.h"
28 #include "tznames_impl.h" // TextTrieMap
29
30 U_NAMESPACE_BEGIN
31
32 // Bit flags used by the parse method.
33 // The order must match UTimeZoneFormatStyle enum.
34 #define ISO_Z_STYLE_FLAG 0x0080
35 #define ISO_LOCAL_STYLE_FLAG 0x0100
36 static const int16_t STYLE_PARSE_FLAGS[] = {
37 0x0001, // UTZFMT_STYLE_GENERIC_LOCATION,
38 0x0002, // UTZFMT_STYLE_GENERIC_LONG,
39 0x0004, // UTZFMT_STYLE_GENERIC_SHORT,
40 0x0008, // UTZFMT_STYLE_SPECIFIC_LONG,
41 0x0010, // UTZFMT_STYLE_SPECIFIC_SHORT,
42 0x0020, // UTZFMT_STYLE_LOCALIZED_GMT,
43 0x0040, // UTZFMT_STYLE_LOCALIZED_GMT_SHORT,
44 ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_SHORT,
45 ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT,
46 ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_FIXED,
47 ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED,
48 ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_FULL,
49 ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL,
50 ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_EXTENDED_FIXED,
51 ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED,
52 ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_EXTENDED_FULL,
53 ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL,
54 0x0200, // UTZFMT_STYLE_ZONE_ID,
55 0x0400, // UTZFMT_STYLE_ZONE_ID_SHORT,
56 0x0800 // UTZFMT_STYLE_EXEMPLAR_LOCATION
57 };
58
59 static const char gZoneStringsTag[] = "zoneStrings";
60 static const char gGmtFormatTag[]= "gmtFormat";
61 static const char gGmtZeroFormatTag[] = "gmtZeroFormat";
62 static const char gHourFormatTag[]= "hourFormat";
63
64 static const UChar TZID_GMT[] = {0x0045, 0x0074, 0x0063, 0x002F, 0x0047, 0x004D, 0x0054, 0}; // Etc/GMT
65 static const UChar UNKNOWN_ZONE_ID[] = {
66 0x0045, 0x0074, 0x0063, 0x002F, 0x0055, 0x006E, 0x006B, 0x006E, 0x006F, 0x0077, 0x006E, 0}; // Etc/Unknown
67 static const UChar UNKNOWN_SHORT_ZONE_ID[] = {0x0075, 0x006E, 0x006B, 0}; // unk
68 static const UChar UNKNOWN_LOCATION[] = {0x0055, 0x006E, 0x006B, 0x006E, 0x006F, 0x0077, 0x006E, 0}; // Unknown
69
70 static const UChar DEFAULT_GMT_PATTERN[] = {0x0047, 0x004D, 0x0054, 0x007B, 0x0030, 0x007D, 0}; // GMT{0}
71 //static const UChar DEFAULT_GMT_ZERO[] = {0x0047, 0x004D, 0x0054, 0}; // GMT
72 static const UChar DEFAULT_GMT_POSITIVE_HM[] = {0x002B, 0x0048, 0x003A, 0x006D, 0x006D, 0}; // +H:mm
73 static const UChar DEFAULT_GMT_POSITIVE_HMS[] = {0x002B, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0}; // +H:mm:ss
74 static const UChar DEFAULT_GMT_NEGATIVE_HM[] = {0x002D, 0x0048, 0x003A, 0x006D, 0x006D, 0}; // -H:mm
75 static const UChar DEFAULT_GMT_NEGATIVE_HMS[] = {0x002D, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0}; // -H:mm:ss
76 static const UChar DEFAULT_GMT_POSITIVE_H[] = {0x002B, 0x0048, 0}; // +H
77 static const UChar DEFAULT_GMT_NEGATIVE_H[] = {0x002D, 0x0048, 0}; // -H
78
79 static const UChar32 DEFAULT_GMT_DIGITS[] = {
80 0x0030, 0x0031, 0x0032, 0x0033, 0x0034,
81 0x0035, 0x0036, 0x0037, 0x0038, 0x0039
82 };
83
84 static const UChar DEFAULT_GMT_OFFSET_SEP = 0x003A; // ':'
85
86 static const UChar ARG0[] = {0x007B, 0x0030, 0x007D}; // "{0}"
87 static const int32_t ARG0_LEN = 3;
88
89 static const UChar DEFAULT_GMT_OFFSET_MINUTE_PATTERN[] = {0x006D, 0x006D, 0}; // "mm"
90 static const UChar DEFAULT_GMT_OFFSET_SECOND_PATTERN[] = {0x0073, 0x0073, 0}; // "ss"
91
92 static const UChar ALT_GMT_STRINGS[][4] = {
93 {0x0047, 0x004D, 0x0054, 0}, // GMT
94 {0x0055, 0x0054, 0x0043, 0}, // UTC
95 {0x0055, 0x0054, 0, 0}, // UT
96 {0, 0, 0, 0}
97 };
98
99 // Order of GMT offset pattern parsing, *_HMS must be evaluated first
100 // because *_HM is most likely a substring of *_HMS
101 static const int32_t PARSE_GMT_OFFSET_TYPES[] = {
102 UTZFMT_PAT_POSITIVE_HMS,
103 UTZFMT_PAT_NEGATIVE_HMS,
104 UTZFMT_PAT_POSITIVE_HM,
105 UTZFMT_PAT_NEGATIVE_HM,
106 UTZFMT_PAT_POSITIVE_H,
107 UTZFMT_PAT_NEGATIVE_H,
108 -1
109 };
110
111 static const UChar SINGLEQUOTE = 0x0027;
112 static const UChar PLUS = 0x002B;
113 static const UChar MINUS = 0x002D;
114 static const UChar ISO8601_UTC = 0x005A; // 'Z'
115 static const UChar ISO8601_SEP = 0x003A; // ':'
116
117 static const int32_t MILLIS_PER_HOUR = 60 * 60 * 1000;
118 static const int32_t MILLIS_PER_MINUTE = 60 * 1000;
119 static const int32_t MILLIS_PER_SECOND = 1000;
120
121 // Maximum offset (exclusive) in millisecond supported by offset formats
122 static int32_t MAX_OFFSET = 24 * MILLIS_PER_HOUR;
123
124 // Maximum values for GMT offset fields
125 static const int32_t MAX_OFFSET_HOUR = 23;
126 static const int32_t MAX_OFFSET_MINUTE = 59;
127 static const int32_t MAX_OFFSET_SECOND = 59;
128
129 static const int32_t UNKNOWN_OFFSET = 0x7FFFFFFF;
130
131 static const int32_t ALL_SIMPLE_NAME_TYPES = UTZNM_LONG_STANDARD | UTZNM_LONG_DAYLIGHT | UTZNM_SHORT_STANDARD | UTZNM_SHORT_DAYLIGHT | UTZNM_EXEMPLAR_LOCATION;
132 static const int32_t ALL_GENERIC_NAME_TYPES = UTZGNM_LOCATION | UTZGNM_LONG | UTZGNM_SHORT;
133
134 #define DIGIT_VAL(c) (0x0030 <= (c) && (c) <= 0x0039 ? (c) - 0x0030 : -1)
135 #define MAX_OFFSET_DIGITS 6
136
137 // Time Zone ID/Short ID trie
138 static TextTrieMap *gZoneIdTrie = NULL;
139 static UBool gZoneIdTrieInitialized = FALSE;
140
141 static TextTrieMap *gShortZoneIdTrie = NULL;
142 static UBool gShortZoneIdTrieInitialized = FALSE;
143
144 static UMutex gLock = U_MUTEX_INITIALIZER;
145
146 U_CDECL_BEGIN
147 /**
148 * Cleanup callback func
149 */
150 static UBool U_CALLCONV tzfmt_cleanup(void)
151 {
152 if (gZoneIdTrie != NULL) {
153 delete gZoneIdTrie;
154 }
155 gZoneIdTrie = NULL;
156 gZoneIdTrieInitialized = FALSE;
157
158 if (gShortZoneIdTrie != NULL) {
159 delete gShortZoneIdTrie;
160 }
161 gShortZoneIdTrie = NULL;
162 gShortZoneIdTrieInitialized = FALSE;
163
164 return TRUE;
165 }
166 U_CDECL_END
167
168 // ------------------------------------------------------------------
169 // GMTOffsetField
170 //
171 // This class represents a localized GMT offset pattern
172 // item and used by TimeZoneFormat
173 // ------------------------------------------------------------------
174 class GMTOffsetField : public UMemory {
175 public:
176 enum FieldType {
177 TEXT = 0,
178 HOUR = 1,
179 MINUTE = 2,
180 SECOND = 4
181 };
182
183 virtual ~GMTOffsetField();
184
185 static GMTOffsetField* createText(const UnicodeString& text, UErrorCode& status);
186 static GMTOffsetField* createTimeField(FieldType type, uint8_t width, UErrorCode& status);
187 static UBool isValid(FieldType type, int32_t width);
188 static FieldType getTypeByLetter(UChar ch);
189
190 FieldType getType() const;
191 uint8_t getWidth() const;
192 const UChar* getPatternText(void) const;
193
194 private:
195 UChar* fText;
196 FieldType fType;
197 uint8_t fWidth;
198
199 GMTOffsetField();
200 };
201
202 GMTOffsetField::GMTOffsetField()
203 : fText(NULL), fType(TEXT), fWidth(0) {
204 }
205
206 GMTOffsetField::~GMTOffsetField() {
207 if (fText) {
208 uprv_free(fText);
209 }
210 }
211
212 GMTOffsetField*
213 GMTOffsetField::createText(const UnicodeString& text, UErrorCode& status) {
214 if (U_FAILURE(status)) {
215 return NULL;
216 }
217 GMTOffsetField* result = new GMTOffsetField();
218 if (result == NULL) {
219 status = U_MEMORY_ALLOCATION_ERROR;
220 return NULL;
221 }
222
223 int32_t len = text.length();
224 result->fText = (UChar*)uprv_malloc((len + 1) * sizeof(UChar));
225 if (result->fText == NULL) {
226 status = U_MEMORY_ALLOCATION_ERROR;
227 delete result;
228 return NULL;
229 }
230 u_strncpy(result->fText, text.getBuffer(), len);
231 result->fText[len] = 0;
232 result->fType = TEXT;
233
234 return result;
235 }
236
237 GMTOffsetField*
238 GMTOffsetField::createTimeField(FieldType type, uint8_t width, UErrorCode& status) {
239 U_ASSERT(type != TEXT);
240 if (U_FAILURE(status)) {
241 return NULL;
242 }
243 GMTOffsetField* result = new GMTOffsetField();
244 if (result == NULL) {
245 status = U_MEMORY_ALLOCATION_ERROR;
246 return NULL;
247 }
248
249 result->fType = type;
250 result->fWidth = width;
251
252 return result;
253 }
254
255 UBool
256 GMTOffsetField::isValid(FieldType type, int32_t width) {
257 switch (type) {
258 case HOUR:
259 return (width == 1 || width == 2);
260 case MINUTE:
261 case SECOND:
262 return (width == 2);
263 default:
264 U_ASSERT(FALSE);
265 }
266 return (width > 0);
267 }
268
269 GMTOffsetField::FieldType
270 GMTOffsetField::getTypeByLetter(UChar ch) {
271 if (ch == 0x0048 /* H */) {
272 return HOUR;
273 } else if (ch == 0x006D /* m */) {
274 return MINUTE;
275 } else if (ch == 0x0073 /* s */) {
276 return SECOND;
277 }
278 return TEXT;
279 }
280
281 inline GMTOffsetField::FieldType
282 GMTOffsetField::getType() const {
283 return fType;
284 }
285
286 inline uint8_t
287 GMTOffsetField::getWidth() const {
288 return fWidth;
289 }
290
291 inline const UChar*
292 GMTOffsetField::getPatternText(void) const {
293 return fText;
294 }
295
296
297 U_CDECL_BEGIN
298 static void U_CALLCONV
299 deleteGMTOffsetField(void *obj) {
300 delete static_cast<GMTOffsetField *>(obj);
301 }
302 U_CDECL_END
303
304
305 // ------------------------------------------------------------------
306 // TimeZoneFormat
307 // ------------------------------------------------------------------
308 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TimeZoneFormat)
309
310 TimeZoneFormat::TimeZoneFormat(const Locale& locale, UErrorCode& status)
311 : fLocale(locale), fTimeZoneNames(NULL), fTimeZoneGenericNames(NULL), fDefParseOptionFlags(0) {
312
313 for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
314 fGMTOffsetPatternItems[i] = NULL;
315 }
316
317 const char* region = fLocale.getCountry();
318 int32_t regionLen = uprv_strlen(region);
319 if (regionLen == 0) {
320 char loc[ULOC_FULLNAME_CAPACITY];
321 uloc_addLikelySubtags(fLocale.getName(), loc, sizeof(loc), &status);
322
323 regionLen = uloc_getCountry(loc, fTargetRegion, sizeof(fTargetRegion), &status);
324 if (U_SUCCESS(status)) {
325 fTargetRegion[regionLen] = 0;
326 } else {
327 return;
328 }
329 } else if (regionLen < (int32_t)sizeof(fTargetRegion)) {
330 uprv_strcpy(fTargetRegion, region);
331 } else {
332 fTargetRegion[0] = 0;
333 }
334
335 fTimeZoneNames = TimeZoneNames::createInstance(locale, status);
336 // fTimeZoneGenericNames is lazily instantiated
337 if (U_FAILURE(status)) {
338 return;
339 }
340
341 const UChar* gmtPattern = NULL;
342 const UChar* hourFormats = NULL;
343
344 UResourceBundle *zoneBundle = ures_open(U_ICUDATA_ZONE, locale.getName(), &status);
345 UResourceBundle *zoneStringsArray = ures_getByKeyWithFallback(zoneBundle, gZoneStringsTag, NULL, &status);
346 if (U_SUCCESS(status)) {
347 const UChar* resStr;
348 int32_t len;
349 resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gGmtFormatTag, &len, &status);
350 if (len > 0) {
351 gmtPattern = resStr;
352 }
353 resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gGmtZeroFormatTag, &len, &status);
354 if (len > 0) {
355 fGMTZeroFormat.setTo(TRUE, resStr, len);
356 }
357 resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gHourFormatTag, &len, &status);
358 if (len > 0) {
359 hourFormats = resStr;
360 }
361 ures_close(zoneStringsArray);
362 ures_close(zoneBundle);
363 }
364
365 if (gmtPattern == NULL) {
366 gmtPattern = DEFAULT_GMT_PATTERN;
367 }
368 initGMTPattern(UnicodeString(gmtPattern, -1), status);
369
370 UBool useDefaultOffsetPatterns = TRUE;
371 if (hourFormats) {
372 UChar *sep = u_strchr(hourFormats, (UChar)0x003B /* ';' */);
373 if (sep != NULL) {
374 UErrorCode tmpStatus = U_ZERO_ERROR;
375 fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM].setTo(FALSE, hourFormats, (int32_t)(sep - hourFormats));
376 fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM].setTo(TRUE, sep + 1, -1);
377 expandOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HMS], tmpStatus);
378 expandOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HMS], tmpStatus);
379 truncateOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_H], tmpStatus);
380 truncateOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_H], tmpStatus);
381 if (U_SUCCESS(tmpStatus)) {
382 useDefaultOffsetPatterns = FALSE;
383 }
384 }
385 }
386 if (useDefaultOffsetPatterns) {
387 fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_H].setTo(TRUE, DEFAULT_GMT_POSITIVE_H, -1);
388 fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM].setTo(TRUE, DEFAULT_GMT_POSITIVE_HM, -1);
389 fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HMS].setTo(TRUE, DEFAULT_GMT_POSITIVE_HMS, -1);
390 fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_H].setTo(TRUE, DEFAULT_GMT_NEGATIVE_H, -1);
391 fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM].setTo(TRUE, DEFAULT_GMT_NEGATIVE_HM, -1);
392 fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HMS].setTo(TRUE, DEFAULT_GMT_NEGATIVE_HMS, -1);
393 }
394 initGMTOffsetPatterns(status);
395
396 NumberingSystem* ns = NumberingSystem::createInstance(locale, status);
397 UBool useDefDigits = TRUE;
398 if (ns && !ns->isAlgorithmic()) {
399 UnicodeString digits = ns->getDescription();
400 useDefDigits = !toCodePoints(digits, fGMTOffsetDigits, 10);
401 }
402 if (useDefDigits) {
403 uprv_memcpy(fGMTOffsetDigits, DEFAULT_GMT_DIGITS, sizeof(UChar32) * 10);
404 }
405 delete ns;
406 }
407
408 TimeZoneFormat::TimeZoneFormat(const TimeZoneFormat& other)
409 : Format(other), fTimeZoneNames(NULL), fTimeZoneGenericNames(NULL) {
410
411 for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
412 fGMTOffsetPatternItems[i] = NULL;
413 }
414 *this = other;
415 }
416
417
418 TimeZoneFormat::~TimeZoneFormat() {
419 delete fTimeZoneNames;
420 delete fTimeZoneGenericNames;
421 for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
422 delete fGMTOffsetPatternItems[i];
423 }
424 }
425
426 TimeZoneFormat&
427 TimeZoneFormat::operator=(const TimeZoneFormat& other) {
428 if (this == &other) {
429 return *this;
430 }
431
432 delete fTimeZoneNames;
433 delete fTimeZoneGenericNames;
434 fTimeZoneGenericNames = NULL;
435
436 fLocale = other.fLocale;
437 uprv_memcpy(fTargetRegion, other.fTargetRegion, sizeof(fTargetRegion));
438
439 fTimeZoneNames = other.fTimeZoneNames->clone();
440 if (other.fTimeZoneGenericNames) {
441 fTimeZoneGenericNames = other.fTimeZoneGenericNames->clone();
442 }
443
444 fGMTPattern = other.fGMTPattern;
445 fGMTPatternPrefix = other.fGMTPatternPrefix;
446 fGMTPatternSuffix = other.fGMTPatternSuffix;
447
448 UErrorCode status = U_ZERO_ERROR;
449 for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
450 fGMTOffsetPatterns[i] = other.fGMTOffsetPatterns[i];
451 delete fGMTOffsetPatternItems[i];
452 }
453 initGMTOffsetPatterns(status);
454 U_ASSERT(U_SUCCESS(status));
455
456 fGMTZeroFormat = other.fGMTZeroFormat;
457
458 uprv_memcpy(fGMTOffsetDigits, other.fGMTOffsetDigits, sizeof(fGMTOffsetDigits));
459
460 fDefParseOptionFlags = other.fDefParseOptionFlags;
461
462 return *this;
463 }
464
465
466 UBool
467 TimeZoneFormat::operator==(const Format& other) const {
468 TimeZoneFormat* tzfmt = (TimeZoneFormat*)&other;
469
470 UBool isEqual =
471 fLocale == tzfmt->fLocale
472 && fGMTPattern == tzfmt->fGMTPattern
473 && fGMTZeroFormat == tzfmt->fGMTZeroFormat
474 && *fTimeZoneNames == *tzfmt->fTimeZoneNames;
475
476 for (int32_t i = 0; i < UTZFMT_PAT_COUNT && isEqual; i++) {
477 isEqual = fGMTOffsetPatterns[i] == tzfmt->fGMTOffsetPatterns[i];
478 }
479 for (int32_t i = 0; i < 10 && isEqual; i++) {
480 isEqual = fGMTOffsetDigits[i] == tzfmt->fGMTOffsetDigits[i];
481 }
482 // TODO
483 // Check fTimeZoneGenericNames. For now,
484 // if fTimeZoneNames is same, fTimeZoneGenericNames should
485 // be also equivalent.
486 return isEqual;
487 }
488
489 Format*
490 TimeZoneFormat::clone() const {
491 return new TimeZoneFormat(*this);
492 }
493
494 TimeZoneFormat* U_EXPORT2
495 TimeZoneFormat::createInstance(const Locale& locale, UErrorCode& status) {
496 TimeZoneFormat* tzfmt = new TimeZoneFormat(locale, status);
497 if (U_SUCCESS(status)) {
498 return tzfmt;
499 }
500 delete tzfmt;
501 return NULL;
502 }
503
504 // ------------------------------------------------------------------
505 // Setter and Getter
506
507 const TimeZoneNames*
508 TimeZoneFormat::getTimeZoneNames() const {
509 return (const TimeZoneNames*)fTimeZoneNames;
510 }
511
512 void
513 TimeZoneFormat::adoptTimeZoneNames(TimeZoneNames *tznames) {
514 delete fTimeZoneNames;
515 fTimeZoneNames = tznames;
516
517 // TODO - We should also update fTimeZoneGenericNames
518 }
519
520 void
521 TimeZoneFormat::setTimeZoneNames(const TimeZoneNames &tznames) {
522 delete fTimeZoneNames;
523 fTimeZoneNames = tznames.clone();
524
525 // TODO - We should also update fTimeZoneGenericNames
526 }
527
528 void
529 TimeZoneFormat::setDefaultParseOptions(uint32_t flags) {
530 fDefParseOptionFlags = flags;
531 }
532
533 uint32_t
534 TimeZoneFormat::getDefaultParseOptions(void) const {
535 return fDefParseOptionFlags;
536 }
537
538
539 UnicodeString&
540 TimeZoneFormat::getGMTPattern(UnicodeString& pattern) const {
541 return pattern.setTo(fGMTPattern);
542 }
543
544 void
545 TimeZoneFormat::setGMTPattern(const UnicodeString& pattern, UErrorCode& status) {
546 initGMTPattern(pattern, status);
547 }
548
549 UnicodeString&
550 TimeZoneFormat::getGMTOffsetPattern(UTimeZoneFormatGMTOffsetPatternType type, UnicodeString& pattern) const {
551 return pattern.setTo(fGMTOffsetPatterns[type]);
552 }
553
554 void
555 TimeZoneFormat::setGMTOffsetPattern(UTimeZoneFormatGMTOffsetPatternType type, const UnicodeString& pattern, UErrorCode& status) {
556 if (U_FAILURE(status)) {
557 return;
558 }
559 if (pattern == fGMTOffsetPatterns[type]) {
560 // No need to reset
561 return;
562 }
563
564 OffsetFields required = FIELDS_HM;
565 switch (type) {
566 case UTZFMT_PAT_POSITIVE_H:
567 case UTZFMT_PAT_NEGATIVE_H:
568 required = FIELDS_H;
569 break;
570 case UTZFMT_PAT_POSITIVE_HM:
571 case UTZFMT_PAT_NEGATIVE_HM:
572 required = FIELDS_HM;
573 break;
574 case UTZFMT_PAT_POSITIVE_HMS:
575 case UTZFMT_PAT_NEGATIVE_HMS:
576 required = FIELDS_HMS;
577 break;
578 default:
579 U_ASSERT(FALSE);
580 break;
581 }
582
583 UVector* patternItems = parseOffsetPattern(pattern, required, status);
584 if (patternItems == NULL) {
585 return;
586 }
587
588 fGMTOffsetPatterns[type].setTo(pattern);
589 delete fGMTOffsetPatternItems[type];
590 fGMTOffsetPatternItems[type] = patternItems;
591 checkAbuttingHoursAndMinutes();
592 }
593
594 UnicodeString&
595 TimeZoneFormat::getGMTOffsetDigits(UnicodeString& digits) const {
596 digits.remove();
597 for (int32_t i = 0; i < 10; i++) {
598 digits.append(fGMTOffsetDigits[i]);
599 }
600 return digits;
601 }
602
603 void
604 TimeZoneFormat::setGMTOffsetDigits(const UnicodeString& digits, UErrorCode& status) {
605 if (U_FAILURE(status)) {
606 return;
607 }
608 UChar32 digitArray[10];
609 if (!toCodePoints(digits, digitArray, 10)) {
610 status = U_ILLEGAL_ARGUMENT_ERROR;
611 return;
612 }
613 uprv_memcpy(fGMTOffsetDigits, digitArray, sizeof(UChar32)*10);
614 }
615
616 UnicodeString&
617 TimeZoneFormat::getGMTZeroFormat(UnicodeString& gmtZeroFormat) const {
618 return gmtZeroFormat.setTo(fGMTZeroFormat);
619 }
620
621 void
622 TimeZoneFormat::setGMTZeroFormat(const UnicodeString& gmtZeroFormat, UErrorCode& status) {
623 if (U_SUCCESS(status)) {
624 if (gmtZeroFormat.isEmpty()) {
625 status = U_ILLEGAL_ARGUMENT_ERROR;
626 } else if (gmtZeroFormat != fGMTZeroFormat) {
627 fGMTZeroFormat.setTo(gmtZeroFormat);
628 }
629 }
630 }
631
632 // ------------------------------------------------------------------
633 // Format and Parse
634
635 UnicodeString&
636 TimeZoneFormat::format(UTimeZoneFormatStyle style, const TimeZone& tz, UDate date,
637 UnicodeString& name, UTimeZoneFormatTimeType* timeType /* = NULL */) const {
638 if (timeType) {
639 *timeType = UTZFMT_TIME_TYPE_UNKNOWN;
640 }
641 switch (style) {
642 case UTZFMT_STYLE_GENERIC_LOCATION:
643 formatGeneric(tz, UTZGNM_LOCATION, date, name);
644 break;
645 case UTZFMT_STYLE_GENERIC_LONG:
646 formatGeneric(tz, UTZGNM_LONG, date, name);
647 break;
648 case UTZFMT_STYLE_GENERIC_SHORT:
649 formatGeneric(tz, UTZGNM_SHORT, date, name);
650 break;
651 case UTZFMT_STYLE_SPECIFIC_LONG:
652 formatSpecific(tz, UTZNM_LONG_STANDARD, UTZNM_LONG_DAYLIGHT, date, name, timeType);
653 break;
654 case UTZFMT_STYLE_SPECIFIC_SHORT:
655 formatSpecific(tz, UTZNM_SHORT_STANDARD, UTZNM_SHORT_DAYLIGHT, date, name, timeType);
656 break;
657 default:
658 // will be handled below
659 break;
660 }
661
662 if (name.isEmpty()) {
663 UErrorCode status = U_ZERO_ERROR;
664 int32_t rawOffset, dstOffset;
665 tz.getOffset(date, FALSE, rawOffset, dstOffset, status);
666 int32_t offset = rawOffset + dstOffset;
667 if (U_SUCCESS(status)) {
668 switch (style) {
669 case UTZFMT_STYLE_GENERIC_LOCATION:
670 case UTZFMT_STYLE_GENERIC_LONG:
671 case UTZFMT_STYLE_SPECIFIC_LONG:
672 case UTZFMT_STYLE_LOCALIZED_GMT:
673 formatOffsetLocalizedGMT(offset, name, status);
674 break;
675
676 case UTZFMT_STYLE_GENERIC_SHORT:
677 case UTZFMT_STYLE_SPECIFIC_SHORT:
678 case UTZFMT_STYLE_LOCALIZED_GMT_SHORT:
679 formatOffsetShortLocalizedGMT(offset, name, status);
680 break;
681
682 case UTZFMT_STYLE_ISO_BASIC_SHORT:
683 formatOffsetISO8601Basic(offset, TRUE, TRUE, TRUE, name, status);
684 break;
685
686 case UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT:
687 formatOffsetISO8601Basic(offset, FALSE, TRUE, TRUE, name, status);
688 break;
689
690 case UTZFMT_STYLE_ISO_BASIC_FIXED:
691 formatOffsetISO8601Basic(offset, TRUE, FALSE, TRUE, name, status);
692 break;
693
694 case UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED:
695 formatOffsetISO8601Basic(offset, FALSE, FALSE, TRUE, name, status);
696 break;
697
698 case UTZFMT_STYLE_ISO_EXTENDED_FIXED:
699 formatOffsetISO8601Extended(offset, TRUE, FALSE, TRUE, name, status);
700 break;
701
702 case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED:
703 formatOffsetISO8601Extended(offset, FALSE, FALSE, TRUE, name, status);
704 break;
705
706 case UTZFMT_STYLE_ISO_BASIC_FULL:
707 formatOffsetISO8601Basic(offset, TRUE, FALSE, FALSE, name, status);
708 break;
709
710 case UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL:
711 formatOffsetISO8601Basic(offset, FALSE, FALSE, FALSE, name, status);
712 break;
713
714 case UTZFMT_STYLE_ISO_EXTENDED_FULL:
715 formatOffsetISO8601Extended(offset, TRUE, FALSE, FALSE, name, status);
716 break;
717
718 case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL:
719 formatOffsetISO8601Extended(offset, FALSE, FALSE, FALSE, name, status);
720 break;
721
722 case UTZFMT_STYLE_ZONE_ID:
723 tz.getID(name);
724 break;
725
726 case UTZFMT_STYLE_ZONE_ID_SHORT:
727 {
728 const UChar* shortID = ZoneMeta::getShortID(tz);
729 if (shortID == NULL) {
730 shortID = UNKNOWN_SHORT_ZONE_ID;
731 }
732 name.setTo(shortID, -1);
733 }
734 break;
735
736 case UTZFMT_STYLE_EXEMPLAR_LOCATION:
737 formatExemplarLocation(tz, name);
738 break;
739 }
740 if (timeType) {
741 *timeType = (dstOffset != 0) ? UTZFMT_TIME_TYPE_DAYLIGHT : UTZFMT_TIME_TYPE_STANDARD;
742 }
743 }
744 }
745
746 return name;
747 }
748
749 UnicodeString&
750 TimeZoneFormat::format(const Formattable& obj, UnicodeString& appendTo,
751 FieldPosition& pos, UErrorCode& status) const {
752 if (U_FAILURE(status)) {
753 return appendTo;
754 }
755 UDate date = Calendar::getNow();
756 if (obj.getType() == Formattable::kObject) {
757 const UObject* formatObj = obj.getObject();
758 const TimeZone* tz = dynamic_cast<const TimeZone*>(formatObj);
759 if (tz == NULL) {
760 const Calendar* cal = dynamic_cast<const Calendar*>(formatObj);
761 if (cal != NULL) {
762 tz = &cal->getTimeZone();
763 date = cal->getTime(status);
764 }
765 }
766 if (tz != NULL) {
767 int32_t rawOffset, dstOffset;
768 tz->getOffset(date, FALSE, rawOffset, dstOffset, status);
769 UnicodeString result;
770 formatOffsetLocalizedGMT(rawOffset + dstOffset, result, status);
771 if (U_SUCCESS(status)) {
772 appendTo.append(result);
773 if (pos.getField() == UDAT_TIMEZONE_FIELD) {
774 pos.setBeginIndex(0);
775 pos.setEndIndex(result.length());
776 }
777 }
778 }
779 }
780 return appendTo;
781 }
782
783 TimeZone*
784 TimeZoneFormat::parse(UTimeZoneFormatStyle style, const UnicodeString& text, ParsePosition& pos,
785 UTimeZoneFormatTimeType* timeType /*= NULL*/) const {
786 return parse(style, text, pos, getDefaultParseOptions(), timeType);
787 }
788
789 TimeZone*
790 TimeZoneFormat::parse(UTimeZoneFormatStyle style, const UnicodeString& text, ParsePosition& pos,
791 int32_t parseOptions, UTimeZoneFormatTimeType* timeType /* = NULL */) const {
792 if (timeType) {
793 *timeType = UTZFMT_TIME_TYPE_UNKNOWN;
794 }
795
796 int32_t startIdx = pos.getIndex();
797 int32_t maxPos = text.length();
798 int32_t offset;
799
800 // Styles using localized GMT format as fallback
801 UBool fallbackLocalizedGMT =
802 (style == UTZFMT_STYLE_SPECIFIC_LONG || style == UTZFMT_STYLE_GENERIC_LONG || style == UTZFMT_STYLE_GENERIC_LOCATION);
803 UBool fallbackShortLocalizedGMT =
804 (style == UTZFMT_STYLE_SPECIFIC_SHORT || style == UTZFMT_STYLE_GENERIC_SHORT);
805
806 int32_t evaluated = 0; // bit flags representing already evaluated styles
807 ParsePosition tmpPos(startIdx);
808
809 int32_t parsedOffset = UNKNOWN_OFFSET; // stores successfully parsed offset for later use
810 int32_t parsedPos = -1; // stores successfully parsed offset position for later use
811
812 // Try localized GMT format first if necessary
813 if (fallbackLocalizedGMT || fallbackShortLocalizedGMT) {
814 UBool hasDigitOffset = FALSE;
815 offset = parseOffsetLocalizedGMT(text, tmpPos, fallbackShortLocalizedGMT, &hasDigitOffset);
816 if (tmpPos.getErrorIndex() == -1) {
817 // Even when the input text was successfully parsed as a localized GMT format text,
818 // we may still need to evaluate the specified style if -
819 // 1) GMT zero format was used, and
820 // 2) The input text was not completely processed
821 if (tmpPos.getIndex() == maxPos || hasDigitOffset) {
822 pos.setIndex(tmpPos.getIndex());
823 return createTimeZoneForOffset(offset);
824 }
825 parsedOffset = offset;
826 parsedPos = tmpPos.getIndex();
827 }
828 // Note: For now, no distinction between long/short localized GMT format in the parser.
829 // This might be changed in future.
830 // evaluated |= (fallbackLocalizedGMT ? STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT] : STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT]);
831 evaluated |= STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT] | STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT];
832 }
833
834 UErrorCode status = U_ZERO_ERROR;
835 UnicodeString tzID;
836
837 // Try the specified style
838 switch (style) {
839 case UTZFMT_STYLE_LOCALIZED_GMT:
840 {
841 tmpPos.setIndex(startIdx);
842 tmpPos.setErrorIndex(-1);
843
844 offset = parseOffsetLocalizedGMT(text, tmpPos);
845 if (tmpPos.getErrorIndex() == -1) {
846 pos.setIndex(tmpPos.getIndex());
847 return createTimeZoneForOffset(offset);
848 }
849
850 // Note: For now, no distinction between long/short localized GMT format in the parser.
851 // This might be changed in future.
852 evaluated |= STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT];
853
854 break;
855 }
856 case UTZFMT_STYLE_LOCALIZED_GMT_SHORT:
857 {
858 tmpPos.setIndex(startIdx);
859 tmpPos.setErrorIndex(-1);
860
861 offset = parseOffsetShortLocalizedGMT(text, tmpPos);
862 if (tmpPos.getErrorIndex() == -1) {
863 pos.setIndex(tmpPos.getIndex());
864 return createTimeZoneForOffset(offset);
865 }
866
867 // Note: For now, no distinction between long/short localized GMT format in the parser.
868 // This might be changed in future.
869 evaluated |= STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT];
870
871 break;
872 }
873 case UTZFMT_STYLE_ISO_BASIC_SHORT:
874 case UTZFMT_STYLE_ISO_BASIC_FIXED:
875 case UTZFMT_STYLE_ISO_BASIC_FULL:
876 case UTZFMT_STYLE_ISO_EXTENDED_FIXED:
877 case UTZFMT_STYLE_ISO_EXTENDED_FULL:
878 {
879 tmpPos.setIndex(startIdx);
880 tmpPos.setErrorIndex(-1);
881
882 offset = parseOffsetISO8601(text, tmpPos);
883 if (tmpPos.getErrorIndex() == -1) {
884 pos.setIndex(tmpPos.getIndex());
885 return createTimeZoneForOffset(offset);
886 }
887
888 break;
889 }
890
891 case UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT:
892 case UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED:
893 case UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL:
894 case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED:
895 case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL:
896 {
897 tmpPos.setIndex(startIdx);
898 tmpPos.setErrorIndex(-1);
899
900 // Exclude the case of UTC Indicator "Z" here
901 UBool hasDigitOffset = FALSE;
902 offset = parseOffsetISO8601(text, tmpPos, FALSE, &hasDigitOffset);
903 if (tmpPos.getErrorIndex() == -1 && hasDigitOffset) {
904 pos.setIndex(tmpPos.getIndex());
905 return createTimeZoneForOffset(offset);
906 }
907
908 break;
909 }
910
911 case UTZFMT_STYLE_SPECIFIC_LONG:
912 case UTZFMT_STYLE_SPECIFIC_SHORT:
913 {
914 // Specific styles
915 int32_t nameTypes = 0;
916 if (style == UTZFMT_STYLE_SPECIFIC_LONG) {
917 nameTypes = (UTZNM_LONG_STANDARD | UTZNM_LONG_DAYLIGHT);
918 } else {
919 U_ASSERT(style == UTZFMT_STYLE_SPECIFIC_SHORT);
920 nameTypes = (UTZNM_SHORT_STANDARD | UTZNM_SHORT_DAYLIGHT);
921 }
922 LocalPointer<TimeZoneNames::MatchInfoCollection> specificMatches(fTimeZoneNames->find(text, startIdx, nameTypes, status));
923 if (U_FAILURE(status)) {
924 pos.setErrorIndex(startIdx);
925 return NULL;
926 }
927 if (!specificMatches.isNull()) {
928 int32_t matchIdx = -1;
929 int32_t matchPos = -1;
930 for (int32_t i = 0; i < specificMatches->size(); i++) {
931 matchPos = startIdx + specificMatches->getMatchLengthAt(i);
932 if (matchPos > parsedPos) {
933 matchIdx = i;
934 parsedPos = matchPos;
935 }
936 }
937 if (matchIdx >= 0) {
938 if (timeType) {
939 *timeType = getTimeType(specificMatches->getNameTypeAt(matchIdx));
940 }
941 pos.setIndex(matchPos);
942 getTimeZoneID(specificMatches.getAlias(), matchIdx, tzID);
943 U_ASSERT(!tzID.isEmpty());
944 return TimeZone::createTimeZone(tzID);
945 }
946 }
947 break;
948 }
949 case UTZFMT_STYLE_GENERIC_LONG:
950 case UTZFMT_STYLE_GENERIC_SHORT:
951 case UTZFMT_STYLE_GENERIC_LOCATION:
952 {
953 int32_t genericNameTypes = 0;
954 switch (style) {
955 case UTZFMT_STYLE_GENERIC_LOCATION:
956 genericNameTypes = UTZGNM_LOCATION;
957 break;
958
959 case UTZFMT_STYLE_GENERIC_LONG:
960 genericNameTypes = UTZGNM_LONG | UTZGNM_LOCATION;
961 break;
962
963 case UTZFMT_STYLE_GENERIC_SHORT:
964 genericNameTypes = UTZGNM_SHORT | UTZGNM_LOCATION;
965 break;
966
967 default:
968 U_ASSERT(FALSE);
969 }
970
971 int32_t len = 0;
972 UTimeZoneFormatTimeType tt = UTZFMT_TIME_TYPE_UNKNOWN;
973 const TimeZoneGenericNames *gnames = getTimeZoneGenericNames(status);
974 if (U_SUCCESS(status)) {
975 len = gnames->findBestMatch(text, startIdx, genericNameTypes, tzID, tt, status);
976 }
977 if (U_FAILURE(status)) {
978 pos.setErrorIndex(startIdx);
979 return NULL;
980 }
981 if (len > 0) {
982 // Found a match
983 if (timeType) {
984 *timeType = tt;
985 }
986 pos.setIndex(startIdx + len);
987 U_ASSERT(!tzID.isEmpty());
988 return TimeZone::createTimeZone(tzID);
989 }
990
991 break;
992 }
993 case UTZFMT_STYLE_ZONE_ID:
994 {
995 tmpPos.setIndex(startIdx);
996 tmpPos.setErrorIndex(-1);
997
998 parseZoneID(text, tmpPos, tzID);
999 if (tmpPos.getErrorIndex() == -1) {
1000 pos.setIndex(tmpPos.getIndex());
1001 return TimeZone::createTimeZone(tzID);
1002 }
1003 break;
1004 }
1005 case UTZFMT_STYLE_ZONE_ID_SHORT:
1006 {
1007 tmpPos.setIndex(startIdx);
1008 tmpPos.setErrorIndex(-1);
1009
1010 parseShortZoneID(text, tmpPos, tzID);
1011 if (tmpPos.getErrorIndex() == -1) {
1012 pos.setIndex(tmpPos.getIndex());
1013 return TimeZone::createTimeZone(tzID);
1014 }
1015 break;
1016 }
1017 case UTZFMT_STYLE_EXEMPLAR_LOCATION:
1018 {
1019 tmpPos.setIndex(startIdx);
1020 tmpPos.setErrorIndex(-1);
1021
1022 parseExemplarLocation(text, tmpPos, tzID);
1023 if (tmpPos.getErrorIndex() == -1) {
1024 pos.setIndex(tmpPos.getIndex());
1025 return TimeZone::createTimeZone(tzID);
1026 }
1027 break;
1028 }
1029 }
1030 evaluated |= STYLE_PARSE_FLAGS[style];
1031
1032
1033 if (parsedPos > startIdx) {
1034 // When the specified style is one of SPECIFIC_XXX or GENERIC_XXX, we tried to parse the input
1035 // as localized GMT format earlier. If parsedOffset is positive, it means it was successfully
1036 // parsed as localized GMT format, but offset digits were not detected (more specifically, GMT
1037 // zero format). Then, it tried to find a match within the set of display names, but could not
1038 // find a match. At this point, we can safely assume the input text contains the localized
1039 // GMT format.
1040 U_ASSERT(parsedOffset != UNKNOWN_OFFSET);
1041 pos.setIndex(parsedPos);
1042 return createTimeZoneForOffset(parsedOffset);
1043 }
1044
1045 // Failed to parse the input text as the time zone format in the specified style.
1046 // Check the longest match among other styles below.
1047 UnicodeString parsedID;
1048 UTimeZoneFormatTimeType parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1049
1050 U_ASSERT(parsedPos < 0);
1051 U_ASSERT(parsedOffset == UNKNOWN_OFFSET);
1052
1053 // ISO 8601
1054 if (parsedPos < maxPos &&
1055 ((evaluated & ISO_Z_STYLE_FLAG) == 0 || (evaluated & ISO_LOCAL_STYLE_FLAG) == 0)) {
1056 tmpPos.setIndex(startIdx);
1057 tmpPos.setErrorIndex(-1);
1058
1059 UBool hasDigitOffset = FALSE;
1060 offset = parseOffsetISO8601(text, tmpPos, FALSE, &hasDigitOffset);
1061 if (tmpPos.getErrorIndex() == -1) {
1062 if (tmpPos.getIndex() == maxPos || hasDigitOffset) {
1063 pos.setIndex(tmpPos.getIndex());
1064 return createTimeZoneForOffset(offset);
1065 }
1066 // Note: When ISO 8601 format contains offset digits, it should not
1067 // collide with other formats. However, ISO 8601 UTC format "Z" (single letter)
1068 // may collide with other names. In this case, we need to evaluate other names.
1069 if (parsedPos < tmpPos.getIndex()) {
1070 parsedOffset = offset;
1071 parsedID.setToBogus();
1072 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1073 parsedPos = tmpPos.getIndex();
1074 U_ASSERT(parsedPos == startIdx + 1); // only when "Z" is used
1075 }
1076 }
1077 }
1078
1079 // Localized GMT format
1080 if (parsedPos < maxPos &&
1081 (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT]) == 0) {
1082 tmpPos.setIndex(startIdx);
1083 tmpPos.setErrorIndex(-1);
1084
1085 UBool hasDigitOffset = FALSE;
1086 offset = parseOffsetLocalizedGMT(text, tmpPos, FALSE, &hasDigitOffset);
1087 if (tmpPos.getErrorIndex() == -1) {
1088 if (tmpPos.getIndex() == maxPos || hasDigitOffset) {
1089 pos.setIndex(tmpPos.getIndex());
1090 return createTimeZoneForOffset(offset);
1091 }
1092 // Evaluate other names - see the comment earlier in this method.
1093 if (parsedPos < tmpPos.getIndex()) {
1094 parsedOffset = offset;
1095 parsedID.setToBogus();
1096 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1097 parsedPos = tmpPos.getIndex();
1098 }
1099 }
1100 }
1101
1102 if (parsedPos < maxPos &&
1103 (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT]) == 0) {
1104 tmpPos.setIndex(startIdx);
1105 tmpPos.setErrorIndex(-1);
1106
1107 UBool hasDigitOffset = FALSE;
1108 offset = parseOffsetLocalizedGMT(text, tmpPos, TRUE, &hasDigitOffset);
1109 if (tmpPos.getErrorIndex() == -1) {
1110 if (tmpPos.getIndex() == maxPos || hasDigitOffset) {
1111 pos.setIndex(tmpPos.getIndex());
1112 return createTimeZoneForOffset(offset);
1113 }
1114 // Evaluate other names - see the comment earlier in this method.
1115 if (parsedPos < tmpPos.getIndex()) {
1116 parsedOffset = offset;
1117 parsedID.setToBogus();
1118 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1119 parsedPos = tmpPos.getIndex();
1120 }
1121 }
1122 }
1123
1124 // When ParseOption.ALL_STYLES is available, we also try to look all possible display names and IDs.
1125 // For example, when style is GENERIC_LONG, "EST" (SPECIFIC_SHORT) is never
1126 // used for America/New_York. With parseAllStyles true, this code parses "EST"
1127 // as America/New_York.
1128
1129 // Note: Adding all possible names into the trie used by the implementation is quite heavy operation,
1130 // which we want to avoid normally (note that we cache the trie, so this is applicable to the
1131 // first time only as long as the cache does not expire).
1132
1133 if (parseOptions & UTZFMT_PARSE_OPTION_ALL_STYLES) {
1134 // Try all specific names and exemplar location names
1135 if (parsedPos < maxPos) {
1136 LocalPointer<TimeZoneNames::MatchInfoCollection> specificMatches(fTimeZoneNames->find(text, startIdx, ALL_SIMPLE_NAME_TYPES, status));
1137 if (U_FAILURE(status)) {
1138 pos.setErrorIndex(startIdx);
1139 return NULL;
1140 }
1141 int32_t specificMatchIdx = -1;
1142 int32_t matchPos = -1;
1143 if (!specificMatches.isNull()) {
1144 for (int32_t i = 0; i < specificMatches->size(); i++) {
1145 if (startIdx + specificMatches->getMatchLengthAt(i) > matchPos) {
1146 specificMatchIdx = i;
1147 matchPos = startIdx + specificMatches->getMatchLengthAt(i);
1148 }
1149 }
1150 }
1151 if (parsedPos < matchPos) {
1152 U_ASSERT(specificMatchIdx >= 0);
1153 parsedPos = matchPos;
1154 getTimeZoneID(specificMatches.getAlias(), specificMatchIdx, parsedID);
1155 parsedTimeType = getTimeType(specificMatches->getNameTypeAt(specificMatchIdx));
1156 parsedOffset = UNKNOWN_OFFSET;
1157 }
1158 }
1159 // Try generic names
1160 if (parsedPos < maxPos) {
1161 int32_t genMatchLen = -1;
1162 UTimeZoneFormatTimeType tt = UTZFMT_TIME_TYPE_UNKNOWN;
1163
1164 const TimeZoneGenericNames *gnames = getTimeZoneGenericNames(status);
1165 if (U_SUCCESS(status)) {
1166 genMatchLen = gnames->findBestMatch(text, startIdx, ALL_GENERIC_NAME_TYPES, tzID, tt, status);
1167 }
1168 if (U_FAILURE(status)) {
1169 pos.setErrorIndex(startIdx);
1170 return NULL;
1171 }
1172
1173 if (parsedPos < startIdx + genMatchLen) {
1174 parsedPos = startIdx + genMatchLen;
1175 parsedID.setTo(tzID);
1176 parsedTimeType = tt;
1177 parsedOffset = UNKNOWN_OFFSET;
1178 }
1179 }
1180
1181 // Try time zone ID
1182 if (parsedPos < maxPos && (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_ZONE_ID]) == 0) {
1183 tmpPos.setIndex(startIdx);
1184 tmpPos.setErrorIndex(-1);
1185
1186 parseZoneID(text, tmpPos, tzID);
1187 if (tmpPos.getErrorIndex() == -1 && parsedPos < tmpPos.getIndex()) {
1188 parsedPos = tmpPos.getIndex();
1189 parsedID.setTo(tzID);
1190 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1191 parsedOffset = UNKNOWN_OFFSET;
1192 }
1193 }
1194 // Try short time zone ID
1195 if (parsedPos < maxPos && (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_ZONE_ID]) == 0) {
1196 tmpPos.setIndex(startIdx);
1197 tmpPos.setErrorIndex(-1);
1198
1199 parseShortZoneID(text, tmpPos, tzID);
1200 if (tmpPos.getErrorIndex() == -1 && parsedPos < tmpPos.getIndex()) {
1201 parsedPos = tmpPos.getIndex();
1202 parsedID.setTo(tzID);
1203 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1204 parsedOffset = UNKNOWN_OFFSET;
1205 }
1206 }
1207 }
1208
1209 if (parsedPos > startIdx) {
1210 // Parsed successfully
1211 TimeZone* parsedTZ;
1212 if (parsedID.length() > 0) {
1213 parsedTZ = TimeZone::createTimeZone(parsedID);
1214 } else {
1215 U_ASSERT(parsedOffset != UNKNOWN_OFFSET);
1216 parsedTZ = createTimeZoneForOffset(parsedOffset);
1217 }
1218 if (timeType) {
1219 *timeType = parsedTimeType;
1220 }
1221 pos.setIndex(parsedPos);
1222 return parsedTZ;
1223 }
1224
1225 pos.setErrorIndex(startIdx);
1226 return NULL;
1227 }
1228
1229 void
1230 TimeZoneFormat::parseObject(const UnicodeString& source, Formattable& result,
1231 ParsePosition& parse_pos) const {
1232 result.adoptObject(parse(UTZFMT_STYLE_GENERIC_LOCATION, source, parse_pos, UTZFMT_PARSE_OPTION_ALL_STYLES));
1233 }
1234
1235
1236 // ------------------------------------------------------------------
1237 // Private zone name format/parse implementation
1238
1239 UnicodeString&
1240 TimeZoneFormat::formatGeneric(const TimeZone& tz, int32_t genType, UDate date, UnicodeString& name) const {
1241 UErrorCode status = U_ZERO_ERROR;
1242 const TimeZoneGenericNames* gnames = getTimeZoneGenericNames(status);
1243 if (U_FAILURE(status)) {
1244 name.setToBogus();
1245 return name;
1246 }
1247
1248 if (genType == UTZGNM_LOCATION) {
1249 const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz);
1250 if (canonicalID == NULL) {
1251 name.setToBogus();
1252 return name;
1253 }
1254 return gnames->getGenericLocationName(UnicodeString(canonicalID), name);
1255 }
1256 return gnames->getDisplayName(tz, (UTimeZoneGenericNameType)genType, date, name);
1257 }
1258
1259 UnicodeString&
1260 TimeZoneFormat::formatSpecific(const TimeZone& tz, UTimeZoneNameType stdType, UTimeZoneNameType dstType,
1261 UDate date, UnicodeString& name, UTimeZoneFormatTimeType *timeType) const {
1262 if (fTimeZoneNames == NULL) {
1263 name.setToBogus();
1264 return name;
1265 }
1266
1267 UErrorCode status = U_ZERO_ERROR;
1268 UBool isDaylight = tz.inDaylightTime(date, status);
1269 const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz);
1270
1271 if (U_FAILURE(status) || canonicalID == NULL) {
1272 name.setToBogus();
1273 return name;
1274 }
1275
1276 if (isDaylight) {
1277 fTimeZoneNames->getDisplayName(UnicodeString(canonicalID), dstType, date, name);
1278 } else {
1279 fTimeZoneNames->getDisplayName(UnicodeString(canonicalID), stdType, date, name);
1280 }
1281
1282 if (timeType && !name.isEmpty()) {
1283 *timeType = isDaylight ? UTZFMT_TIME_TYPE_DAYLIGHT : UTZFMT_TIME_TYPE_STANDARD;
1284 }
1285 return name;
1286 }
1287
1288 const TimeZoneGenericNames*
1289 TimeZoneFormat::getTimeZoneGenericNames(UErrorCode& status) const {
1290 if (U_FAILURE(status)) {
1291 return NULL;
1292 }
1293
1294 UBool create;
1295 UMTX_CHECK(&gZoneMetaLock, (fTimeZoneGenericNames == NULL), create);
1296 if (create) {
1297 TimeZoneFormat *nonConstThis = const_cast<TimeZoneFormat *>(this);
1298 umtx_lock(&gLock);
1299 {
1300 if (fTimeZoneGenericNames == NULL) {
1301 nonConstThis->fTimeZoneGenericNames = TimeZoneGenericNames::createInstance(fLocale, status);
1302 }
1303 }
1304 umtx_unlock(&gLock);
1305 }
1306
1307 return fTimeZoneGenericNames;
1308 }
1309
1310 UnicodeString&
1311 TimeZoneFormat::formatExemplarLocation(const TimeZone& tz, UnicodeString& name) const {
1312 UnicodeString location;
1313 const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz);
1314
1315 if (canonicalID) {
1316 fTimeZoneNames->getExemplarLocationName(UnicodeString(canonicalID), location);
1317 }
1318 if (location.length() > 0) {
1319 name.setTo(location);
1320 } else {
1321 // Use "unknown" location
1322 fTimeZoneNames->getExemplarLocationName(UnicodeString(UNKNOWN_ZONE_ID), location);
1323 if (location.length() > 0) {
1324 name.setTo(location);
1325 } else {
1326 // last resort
1327 name.setTo(UNKNOWN_LOCATION, -1);
1328 }
1329 }
1330 return name;
1331 }
1332
1333
1334 // ------------------------------------------------------------------
1335 // Zone offset format and parse
1336
1337 UnicodeString&
1338 TimeZoneFormat::formatOffsetISO8601Basic(int32_t offset, UBool useUtcIndicator, UBool isShort, UBool ignoreSeconds,
1339 UnicodeString& result, UErrorCode& status) const {
1340 return formatOffsetISO8601(offset, TRUE, useUtcIndicator, isShort, ignoreSeconds, result, status);
1341 }
1342
1343 UnicodeString&
1344 TimeZoneFormat::formatOffsetISO8601Extended(int32_t offset, UBool useUtcIndicator, UBool isShort, UBool ignoreSeconds,
1345 UnicodeString& result, UErrorCode& status) const {
1346 return formatOffsetISO8601(offset, FALSE, useUtcIndicator, isShort, ignoreSeconds, result, status);
1347 }
1348
1349 UnicodeString&
1350 TimeZoneFormat::formatOffsetLocalizedGMT(int32_t offset, UnicodeString& result, UErrorCode& status) const {
1351 return formatOffsetLocalizedGMT(offset, FALSE, result, status);
1352 }
1353
1354 UnicodeString&
1355 TimeZoneFormat::formatOffsetShortLocalizedGMT(int32_t offset, UnicodeString& result, UErrorCode& status) const {
1356 return formatOffsetLocalizedGMT(offset, TRUE, result, status);
1357 }
1358
1359 int32_t
1360 TimeZoneFormat::parseOffsetISO8601(const UnicodeString& text, ParsePosition& pos) const {
1361 return parseOffsetISO8601(text, pos, FALSE);
1362 }
1363
1364 int32_t
1365 TimeZoneFormat::parseOffsetLocalizedGMT(const UnicodeString& text, ParsePosition& pos) const {
1366 return parseOffsetLocalizedGMT(text, pos, FALSE, NULL);
1367 }
1368
1369 int32_t
1370 TimeZoneFormat::parseOffsetShortLocalizedGMT(const UnicodeString& text, ParsePosition& pos) const {
1371 return parseOffsetLocalizedGMT(text, pos, TRUE, NULL);
1372 }
1373
1374 // ------------------------------------------------------------------
1375 // Private zone offset format/parse implementation
1376
1377 UnicodeString&
1378 TimeZoneFormat::formatOffsetISO8601(int32_t offset, UBool isBasic, UBool useUtcIndicator,
1379 UBool isShort, UBool ignoreSeconds, UnicodeString& result, UErrorCode& status) const {
1380 if (U_FAILURE(status)) {
1381 result.setToBogus();
1382 return result;
1383 }
1384 int32_t absOffset = offset < 0 ? -offset : offset;
1385 if (useUtcIndicator && (absOffset < MILLIS_PER_SECOND || (ignoreSeconds && absOffset < MILLIS_PER_MINUTE))) {
1386 result.setTo(ISO8601_UTC);
1387 return result;
1388 }
1389
1390 OffsetFields minFields = isShort ? FIELDS_H : FIELDS_HM;
1391 OffsetFields maxFields = ignoreSeconds ? FIELDS_HM : FIELDS_HMS;
1392 UChar sep = isBasic ? 0 : ISO8601_SEP;
1393
1394 // Note: FIELDS_HMS as maxFields is a CLDR/ICU extension. ISO 8601 specification does
1395 // not support seconds field.
1396
1397 if (absOffset >= MAX_OFFSET) {
1398 result.setToBogus();
1399 status = U_ILLEGAL_ARGUMENT_ERROR;
1400 return result;
1401 }
1402
1403 int fields[3];
1404 fields[0] = absOffset / MILLIS_PER_HOUR;
1405 absOffset = absOffset % MILLIS_PER_HOUR;
1406 fields[1] = absOffset / MILLIS_PER_MINUTE;
1407 absOffset = absOffset % MILLIS_PER_MINUTE;
1408 fields[2] = absOffset / MILLIS_PER_SECOND;
1409
1410 U_ASSERT(fields[0] >= 0 && fields[0] <= MAX_OFFSET_HOUR);
1411 U_ASSERT(fields[1] >= 0 && fields[1] <= MAX_OFFSET_MINUTE);
1412 U_ASSERT(fields[2] >= 0 && fields[2] <= MAX_OFFSET_SECOND);
1413
1414 int32_t lastIdx = maxFields;
1415 while (lastIdx > minFields) {
1416 if (fields[lastIdx] != 0) {
1417 break;
1418 }
1419 lastIdx--;
1420 }
1421
1422 UChar sign = PLUS;
1423 if (offset < 0) {
1424 // if all output fields are 0s, do not use negative sign
1425 for (int32_t idx = 0; idx <= lastIdx; idx++) {
1426 if (fields[idx] != 0) {
1427 sign = MINUS;
1428 break;
1429 }
1430 }
1431 }
1432 result.setTo(sign);
1433
1434 for (int32_t idx = 0; idx <= lastIdx; idx++) {
1435 if (sep && idx != 0) {
1436 result.append(sep);
1437 }
1438 result.append((UChar)(0x0030 + fields[idx]/10));
1439 result.append((UChar)(0x0030 + fields[idx]%10));
1440 }
1441
1442 return result;
1443 }
1444
1445 UnicodeString&
1446 TimeZoneFormat::formatOffsetLocalizedGMT(int32_t offset, UBool isShort, UnicodeString& result, UErrorCode& status) const {
1447 if (U_FAILURE(status)) {
1448 result.setToBogus();
1449 return result;
1450 }
1451 if (offset <= -MAX_OFFSET || offset >= MAX_OFFSET) {
1452 result.setToBogus();
1453 status = U_ILLEGAL_ARGUMENT_ERROR;
1454 return result;
1455 }
1456
1457 if (offset == 0) {
1458 result.setTo(fGMTZeroFormat);
1459 return result;
1460 }
1461
1462 UBool positive = TRUE;
1463 if (offset < 0) {
1464 offset = -offset;
1465 positive = FALSE;
1466 }
1467
1468 int32_t offsetH = offset / MILLIS_PER_HOUR;
1469 offset = offset % MILLIS_PER_HOUR;
1470 int32_t offsetM = offset / MILLIS_PER_MINUTE;
1471 offset = offset % MILLIS_PER_MINUTE;
1472 int32_t offsetS = offset / MILLIS_PER_SECOND;
1473
1474 U_ASSERT(offsetH <= MAX_OFFSET_HOUR && offsetM <= MAX_OFFSET_MINUTE && offsetS <= MAX_OFFSET_SECOND);
1475
1476 const UVector* offsetPatternItems = NULL;
1477 if (positive) {
1478 if (offsetS != 0) {
1479 offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_HMS];
1480 } else if (offsetM != 0 || !isShort) {
1481 offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_HM];
1482 } else {
1483 offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_H];
1484 }
1485 } else {
1486 if (offsetS != 0) {
1487 offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_HMS];
1488 } else if (offsetM != 0 || !isShort) {
1489 offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_HM];
1490 } else {
1491 offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_H];
1492 }
1493 }
1494
1495 U_ASSERT(offsetPatternItems != NULL);
1496
1497 // Building the GMT format string
1498 result.setTo(fGMTPatternPrefix);
1499
1500 for (int32_t i = 0; i < offsetPatternItems->size(); i++) {
1501 const GMTOffsetField* item = (GMTOffsetField*)offsetPatternItems->elementAt(i);
1502 GMTOffsetField::FieldType type = item->getType();
1503
1504 switch (type) {
1505 case GMTOffsetField::TEXT:
1506 result.append(item->getPatternText(), -1);
1507 break;
1508
1509 case GMTOffsetField::HOUR:
1510 appendOffsetDigits(result, offsetH, (isShort ? 1 : 2));
1511 break;
1512
1513 case GMTOffsetField::MINUTE:
1514 appendOffsetDigits(result, offsetM, 2);
1515 break;
1516
1517 case GMTOffsetField::SECOND:
1518 appendOffsetDigits(result, offsetS, 2);
1519 break;
1520 }
1521 }
1522
1523 result.append(fGMTPatternSuffix);
1524 return result;
1525 }
1526
1527 int32_t
1528 TimeZoneFormat::parseOffsetISO8601(const UnicodeString& text, ParsePosition& pos, UBool extendedOnly, UBool* hasDigitOffset /* = NULL */) const {
1529 if (hasDigitOffset) {
1530 *hasDigitOffset = FALSE;
1531 }
1532 int32_t start = pos.getIndex();
1533 if (start >= text.length()) {
1534 pos.setErrorIndex(start);
1535 return 0;
1536 }
1537
1538 UChar firstChar = text.charAt(start);
1539 if (firstChar == ISO8601_UTC || firstChar == (UChar)(ISO8601_UTC + 0x20)) {
1540 // "Z" (or "z") - indicates UTC
1541 pos.setIndex(start + 1);
1542 return 0;
1543 }
1544
1545 int32_t sign = 1;
1546 if (firstChar == PLUS) {
1547 sign = 1;
1548 } else if (firstChar == MINUS) {
1549 sign = -1;
1550 } else {
1551 // Not an ISO 8601 offset string
1552 pos.setErrorIndex(start);
1553 return 0;
1554 }
1555 ParsePosition posOffset(start + 1);
1556 int32_t offset = parseAsciiOffsetFields(text, posOffset, ISO8601_SEP, FIELDS_H, FIELDS_HMS);
1557 if (posOffset.getErrorIndex() == -1 && !extendedOnly && (posOffset.getIndex() - start <= 3)) {
1558 // If the text is successfully parsed as extended format with the options above, it can be also parsed
1559 // as basic format. For example, "0230" can be parsed as offset 2:00 (only first digits are valid for
1560 // extended format), but it can be parsed as offset 2:30 with basic format. We use longer result.
1561 ParsePosition posBasic(start + 1);
1562 int32_t tmpOffset = parseAbuttingAsciiOffsetFields(text, posBasic, FIELDS_H, FIELDS_HMS, FALSE);
1563 if (posBasic.getErrorIndex() == -1 && posBasic.getIndex() > posOffset.getIndex()) {
1564 offset = tmpOffset;
1565 posOffset.setIndex(posBasic.getIndex());
1566 }
1567 }
1568
1569 if (posOffset.getErrorIndex() != -1) {
1570 pos.setErrorIndex(start);
1571 return 0;
1572 }
1573
1574 pos.setIndex(posOffset.getIndex());
1575 if (hasDigitOffset) {
1576 *hasDigitOffset = TRUE;
1577 }
1578 return sign * offset;
1579 }
1580
1581 int32_t
1582 TimeZoneFormat::parseOffsetLocalizedGMT(const UnicodeString& text, ParsePosition& pos, UBool isShort, UBool* hasDigitOffset) const {
1583 int32_t start = pos.getIndex();
1584 int32_t offset = 0;
1585 int32_t parsedLength = 0;
1586
1587 if (hasDigitOffset) {
1588 *hasDigitOffset = FALSE;
1589 }
1590
1591 offset = parseOffsetLocalizedGMTPattern(text, start, isShort, parsedLength);
1592
1593 // For now, parseOffsetLocalizedGMTPattern handles both long and short
1594 // formats, no matter isShort is true or false. This might be changed in future
1595 // when strict parsing is necessary, or different set of patterns are used for
1596 // short/long formats.
1597 #if 0
1598 if (parsedLength == 0) {
1599 offset = parseOffsetLocalizedGMTPattern(text, start, !isShort, parsedLength);
1600 }
1601 #endif
1602
1603 if (parsedLength > 0) {
1604 if (hasDigitOffset) {
1605 *hasDigitOffset = TRUE;
1606 }
1607 pos.setIndex(start + parsedLength);
1608 return offset;
1609 }
1610
1611 // Try the default patterns
1612 offset = parseOffsetDefaultLocalizedGMT(text, start, parsedLength);
1613 if (parsedLength > 0) {
1614 if (hasDigitOffset) {
1615 *hasDigitOffset = TRUE;
1616 }
1617 pos.setIndex(start + parsedLength);
1618 return offset;
1619 }
1620
1621 // Check if this is a GMT zero format
1622 if (text.caseCompare(start, fGMTZeroFormat.length(), fGMTZeroFormat, 0) == 0) {
1623 pos.setIndex(start + fGMTZeroFormat.length());
1624 return 0;
1625 }
1626
1627 // Check if this is a default GMT zero format
1628 for (int32_t i = 0; ALT_GMT_STRINGS[i][0] != 0; i++) {
1629 const UChar* defGMTZero = ALT_GMT_STRINGS[i];
1630 int32_t defGMTZeroLen = u_strlen(defGMTZero);
1631 if (text.caseCompare(start, defGMTZeroLen, defGMTZero, 0) == 0) {
1632 pos.setIndex(start + defGMTZeroLen);
1633 return 0;
1634 }
1635 }
1636
1637 // Nothing matched
1638 pos.setErrorIndex(start);
1639 return 0;
1640 }
1641
1642 int32_t
1643 TimeZoneFormat::parseOffsetLocalizedGMTPattern(const UnicodeString& text, int32_t start, UBool /*isShort*/, int32_t& parsedLen) const {
1644 int32_t idx = start;
1645 int32_t offset = 0;
1646 UBool parsed = FALSE;
1647
1648 do {
1649 // Prefix part
1650 int32_t len = fGMTPatternPrefix.length();
1651 if (len > 0 && text.caseCompare(idx, len, fGMTPatternPrefix, 0) != 0) {
1652 // prefix match failed
1653 break;
1654 }
1655 idx += len;
1656
1657 // Offset part
1658 offset = parseOffsetFields(text, idx, FALSE, len);
1659 if (len == 0) {
1660 // offset field match failed
1661 break;
1662 }
1663 idx += len;
1664
1665 len = fGMTPatternSuffix.length();
1666 if (len > 0 && text.caseCompare(idx, len, fGMTPatternSuffix, 0) != 0) {
1667 // no suffix match
1668 break;
1669 }
1670 idx += len;
1671 parsed = TRUE;
1672 } while (FALSE);
1673
1674 parsedLen = parsed ? idx - start : 0;
1675 return offset;
1676 }
1677
1678 int32_t
1679 TimeZoneFormat::parseOffsetFields(const UnicodeString& text, int32_t start, UBool /*isShort*/, int32_t& parsedLen) const {
1680 int32_t outLen = 0;
1681 int32_t offset = 0;
1682 int32_t sign = 1;
1683
1684 parsedLen = 0;
1685
1686 int32_t offsetH, offsetM, offsetS;
1687 offsetH = offsetM = offsetS = 0;
1688
1689 for (int32_t patidx = 0; PARSE_GMT_OFFSET_TYPES[patidx] >= 0; patidx++) {
1690 int32_t gmtPatType = PARSE_GMT_OFFSET_TYPES[patidx];
1691 UVector* items = fGMTOffsetPatternItems[gmtPatType];
1692 U_ASSERT(items != NULL);
1693
1694 outLen = parseOffsetFieldsWithPattern(text, start, items, FALSE, offsetH, offsetM, offsetS);
1695 if (outLen > 0) {
1696 sign = (gmtPatType == UTZFMT_PAT_POSITIVE_H || gmtPatType == UTZFMT_PAT_POSITIVE_HM || gmtPatType == UTZFMT_PAT_POSITIVE_HMS) ?
1697 1 : -1;
1698 break;
1699 }
1700 }
1701
1702 if (outLen > 0 && fAbuttingOffsetHoursAndMinutes) {
1703 // When hours field is sabutting minutes field,
1704 // the parse result above may not be appropriate.
1705 // For example, "01020" is parsed as 01:02: above,
1706 // but it should be parsed as 00:10:20.
1707 int32_t tmpLen = 0;
1708 int32_t tmpSign = 1;
1709 int32_t tmpH, tmpM, tmpS;
1710
1711 for (int32_t patidx = 0; PARSE_GMT_OFFSET_TYPES[patidx] >= 0; patidx++) {
1712 int32_t gmtPatType = PARSE_GMT_OFFSET_TYPES[patidx];
1713 UVector* items = fGMTOffsetPatternItems[gmtPatType];
1714 U_ASSERT(items != NULL);
1715
1716 // forcing parse to use single hour digit
1717 tmpLen = parseOffsetFieldsWithPattern(text, start, items, TRUE, tmpH, tmpM, tmpS);
1718 if (tmpLen > 0) {
1719 tmpSign = (gmtPatType == UTZFMT_PAT_POSITIVE_H || gmtPatType == UTZFMT_PAT_POSITIVE_HM || gmtPatType == UTZFMT_PAT_POSITIVE_HMS) ?
1720 1 : -1;
1721 break;
1722 }
1723 }
1724 if (tmpLen > outLen) {
1725 // Better parse result with single hour digit
1726 outLen = tmpLen;
1727 sign = tmpSign;
1728 offsetH = tmpH;
1729 offsetM = tmpM;
1730 offsetS = tmpS;
1731 }
1732 }
1733
1734 if (outLen > 0) {
1735 offset = ((((offsetH * 60) + offsetM) * 60) + offsetS) * 1000 * sign;
1736 parsedLen = outLen;
1737 }
1738
1739 return offset;
1740 }
1741
1742 int32_t
1743 TimeZoneFormat::parseOffsetFieldsWithPattern(const UnicodeString& text, int32_t start,
1744 UVector* patternItems, UBool forceSingleHourDigit, int32_t& hour, int32_t& min, int32_t& sec) const {
1745 UBool failed = FALSE;
1746 int32_t offsetH, offsetM, offsetS;
1747 offsetH = offsetM = offsetS = 0;
1748 int32_t idx = start;
1749
1750 for (int32_t i = 0; i < patternItems->size(); i++) {
1751 int32_t len;
1752 const GMTOffsetField* field = (const GMTOffsetField*)patternItems->elementAt(i);
1753 GMTOffsetField::FieldType fieldType = field->getType();
1754 if (fieldType == GMTOffsetField::TEXT) {
1755 const UChar* patStr = field->getPatternText();
1756 len = u_strlen(patStr);
1757 if (text.caseCompare(idx, len, patStr, 0) != 0) {
1758 failed = TRUE;
1759 break;
1760 }
1761 idx += len;
1762 } else {
1763 if (fieldType == GMTOffsetField::HOUR) {
1764 uint8_t maxDigits = forceSingleHourDigit ? 1 : 2;
1765 offsetH = parseOffsetFieldWithLocalizedDigits(text, idx, 1, maxDigits, 0, MAX_OFFSET_HOUR, len);
1766 } else if (fieldType == GMTOffsetField::MINUTE) {
1767 offsetM = parseOffsetFieldWithLocalizedDigits(text, idx, 2, 2, 0, MAX_OFFSET_MINUTE, len);
1768 } else if (fieldType == GMTOffsetField::SECOND) {
1769 offsetS = parseOffsetFieldWithLocalizedDigits(text, idx, 2, 2, 0, MAX_OFFSET_SECOND, len);
1770 }
1771
1772 if (len == 0) {
1773 failed = TRUE;
1774 break;
1775 }
1776 idx += len;
1777 }
1778 }
1779
1780 if (failed) {
1781 hour = min = sec = 0;
1782 return 0;
1783 }
1784
1785 hour = offsetH;
1786 min = offsetM;
1787 sec = offsetS;
1788
1789 return idx - start;
1790 }
1791
1792 int32_t
1793 TimeZoneFormat::parseAbuttingOffsetFields(const UnicodeString& text, int32_t start, int32_t& parsedLen) const {
1794 int32_t digits[MAX_OFFSET_DIGITS];
1795 int32_t parsed[MAX_OFFSET_DIGITS]; // accumulative offsets
1796
1797 // Parse digits into int[]
1798 int32_t idx = start;
1799 int32_t len = 0;
1800 int32_t numDigits = 0;
1801 for (int32_t i = 0; i < MAX_OFFSET_DIGITS; i++) {
1802 digits[i] = parseSingleLocalizedDigit(text, idx, len);
1803 if (digits[i] < 0) {
1804 break;
1805 }
1806 idx += len;
1807 parsed[i] = idx - start;
1808 numDigits++;
1809 }
1810
1811 if (numDigits == 0) {
1812 parsedLen = 0;
1813 return 0;
1814 }
1815
1816 int32_t offset = 0;
1817 while (numDigits > 0) {
1818 int32_t hour = 0;
1819 int32_t min = 0;
1820 int32_t sec = 0;
1821
1822 U_ASSERT(numDigits > 0 && numDigits <= MAX_OFFSET_DIGITS);
1823 switch (numDigits) {
1824 case 1: // H
1825 hour = digits[0];
1826 break;
1827 case 2: // HH
1828 hour = digits[0] * 10 + digits[1];
1829 break;
1830 case 3: // Hmm
1831 hour = digits[0];
1832 min = digits[1] * 10 + digits[2];
1833 break;
1834 case 4: // HHmm
1835 hour = digits[0] * 10 + digits[1];
1836 min = digits[2] * 10 + digits[3];
1837 break;
1838 case 5: // Hmmss
1839 hour = digits[0];
1840 min = digits[1] * 10 + digits[2];
1841 sec = digits[3] * 10 + digits[4];
1842 break;
1843 case 6: // HHmmss
1844 hour = digits[0] * 10 + digits[1];
1845 min = digits[2] * 10 + digits[3];
1846 sec = digits[4] * 10 + digits[5];
1847 break;
1848 }
1849 if (hour <= MAX_OFFSET_HOUR && min <= MAX_OFFSET_MINUTE && sec <= MAX_OFFSET_SECOND) {
1850 // found a valid combination
1851 offset = hour * MILLIS_PER_HOUR + min * MILLIS_PER_MINUTE + sec * MILLIS_PER_SECOND;
1852 parsedLen = parsed[numDigits - 1];
1853 break;
1854 }
1855 numDigits--;
1856 }
1857 return offset;
1858 }
1859
1860 int32_t
1861 TimeZoneFormat::parseOffsetDefaultLocalizedGMT(const UnicodeString& text, int start, int32_t& parsedLen) const {
1862 int32_t idx = start;
1863 int32_t offset = 0;
1864 int32_t parsed = 0;
1865
1866 do {
1867 // check global default GMT alternatives
1868 int32_t gmtLen = 0;
1869
1870 for (int32_t i = 0; ALT_GMT_STRINGS[i][0] != 0; i++) {
1871 const UChar* gmt = ALT_GMT_STRINGS[i];
1872 int32_t len = u_strlen(gmt);
1873 if (text.caseCompare(start, len, gmt, 0) == 0) {
1874 gmtLen = len;
1875 break;
1876 }
1877 }
1878 if (gmtLen == 0) {
1879 break;
1880 }
1881 idx += gmtLen;
1882
1883 // offset needs a sign char and a digit at minimum
1884 if (idx + 1 >= text.length()) {
1885 break;
1886 }
1887
1888 // parse sign
1889 int32_t sign = 1;
1890 UChar c = text.charAt(idx);
1891 if (c == PLUS) {
1892 sign = 1;
1893 } else if (c == MINUS) {
1894 sign = -1;
1895 } else {
1896 break;
1897 }
1898 idx++;
1899
1900 // offset part
1901 // try the default pattern with the separator first
1902 int32_t lenWithSep = 0;
1903 int32_t offsetWithSep = parseDefaultOffsetFields(text, idx, DEFAULT_GMT_OFFSET_SEP, lenWithSep);
1904 if (lenWithSep == text.length() - idx) {
1905 // maximum match
1906 offset = offsetWithSep * sign;
1907 idx += lenWithSep;
1908 } else {
1909 // try abutting field pattern
1910 int32_t lenAbut = 0;
1911 int32_t offsetAbut = parseAbuttingOffsetFields(text, idx, lenAbut);
1912
1913 if (lenWithSep > lenAbut) {
1914 offset = offsetWithSep * sign;
1915 idx += lenWithSep;
1916 } else {
1917 offset = offsetAbut * sign;
1918 idx += lenAbut;
1919 }
1920 }
1921 parsed = idx - start;
1922 } while (false);
1923
1924 parsedLen = parsed;
1925 return offset;
1926 }
1927
1928 int32_t
1929 TimeZoneFormat::parseDefaultOffsetFields(const UnicodeString& text, int32_t start, UChar separator, int32_t& parsedLen) const {
1930 int32_t max = text.length();
1931 int32_t idx = start;
1932 int32_t len = 0;
1933 int32_t hour = 0, min = 0, sec = 0;
1934
1935 parsedLen = 0;
1936
1937 do {
1938 hour = parseOffsetFieldWithLocalizedDigits(text, idx, 1, 2, 0, MAX_OFFSET_HOUR, len);
1939 if (len == 0) {
1940 break;
1941 }
1942 idx += len;
1943
1944 if (idx + 1 < max && text.charAt(idx) == separator) {
1945 min = parseOffsetFieldWithLocalizedDigits(text, idx + 1, 2, 2, 0, MAX_OFFSET_MINUTE, len);
1946 if (len == 0) {
1947 break;
1948 }
1949 idx += (1 + len);
1950
1951 if (idx + 1 < max && text.charAt(idx) == separator) {
1952 sec = parseOffsetFieldWithLocalizedDigits(text, idx + 1, 2, 2, 0, MAX_OFFSET_SECOND, len);
1953 if (len == 0) {
1954 break;
1955 }
1956 idx += (1 + len);
1957 }
1958 }
1959 } while (FALSE);
1960
1961 if (idx == start) {
1962 return 0;
1963 }
1964
1965 parsedLen = idx - start;
1966 return hour * MILLIS_PER_HOUR + min * MILLIS_PER_MINUTE + sec * MILLIS_PER_SECOND;
1967 }
1968
1969 int32_t
1970 TimeZoneFormat::parseOffsetFieldWithLocalizedDigits(const UnicodeString& text, int32_t start, uint8_t minDigits, uint8_t maxDigits, uint16_t minVal, uint16_t maxVal, int32_t& parsedLen) const {
1971 parsedLen = 0;
1972
1973 int32_t decVal = 0;
1974 int32_t numDigits = 0;
1975 int32_t idx = start;
1976 int32_t digitLen = 0;
1977
1978 while (idx < text.length() && numDigits < maxDigits) {
1979 int32_t digit = parseSingleLocalizedDigit(text, idx, digitLen);
1980 if (digit < 0) {
1981 break;
1982 }
1983 int32_t tmpVal = decVal * 10 + digit;
1984 if (tmpVal > maxVal) {
1985 break;
1986 }
1987 decVal = tmpVal;
1988 numDigits++;
1989 idx += digitLen;
1990 }
1991
1992 // Note: maxVal is checked in the while loop
1993 if (numDigits < minDigits || decVal < minVal) {
1994 decVal = -1;
1995 numDigits = 0;
1996 } else {
1997 parsedLen = idx - start;
1998 }
1999
2000 return decVal;
2001 }
2002
2003 int32_t
2004 TimeZoneFormat::parseSingleLocalizedDigit(const UnicodeString& text, int32_t start, int32_t& len) const {
2005 int32_t digit = -1;
2006 len = 0;
2007 if (start < text.length()) {
2008 UChar32 cp = text.char32At(start);
2009
2010 // First, try digits configured for this instance
2011 for (int32_t i = 0; i < 10; i++) {
2012 if (cp == fGMTOffsetDigits[i]) {
2013 digit = i;
2014 break;
2015 }
2016 }
2017 // If failed, check if this is a Unicode digit
2018 if (digit < 0) {
2019 int32_t tmp = u_charDigitValue(cp);
2020 digit = (tmp >= 0 && tmp <= 9) ? tmp : -1;
2021 }
2022
2023 if (digit >= 0) {
2024 int32_t next = text.moveIndex32(start, 1);
2025 len = next - start;
2026 }
2027 }
2028 return digit;
2029 }
2030
2031 UnicodeString&
2032 TimeZoneFormat::formatOffsetWithAsciiDigits(int32_t offset, UChar sep, OffsetFields minFields, OffsetFields maxFields, UnicodeString& result) {
2033 U_ASSERT(maxFields >= minFields);
2034 U_ASSERT(offset > -MAX_OFFSET && offset < MAX_OFFSET);
2035
2036 UChar sign = PLUS;
2037 if (offset < 0) {
2038 sign = MINUS;
2039 offset = -offset;
2040 }
2041 result.setTo(sign);
2042
2043 int fields[3];
2044 fields[0] = offset / MILLIS_PER_HOUR;
2045 offset = offset % MILLIS_PER_HOUR;
2046 fields[1] = offset / MILLIS_PER_MINUTE;
2047 offset = offset % MILLIS_PER_MINUTE;
2048 fields[2] = offset / MILLIS_PER_SECOND;
2049
2050 U_ASSERT(fields[0] >= 0 && fields[0] <= MAX_OFFSET_HOUR);
2051 U_ASSERT(fields[1] >= 0 && fields[1] <= MAX_OFFSET_MINUTE);
2052 U_ASSERT(fields[2] >= 0 && fields[2] <= MAX_OFFSET_SECOND);
2053
2054 int32_t lastIdx = maxFields;
2055 while (lastIdx > minFields) {
2056 if (fields[lastIdx] != 0) {
2057 break;
2058 }
2059 lastIdx--;
2060 }
2061
2062 for (int32_t idx = 0; idx <= lastIdx; idx++) {
2063 if (sep && idx != 0) {
2064 result.append(sep);
2065 }
2066 result.append((UChar)(0x0030 + fields[idx]/10));
2067 result.append((UChar)(0x0030 + fields[idx]%10));
2068 }
2069
2070 return result;
2071 }
2072
2073 int32_t
2074 TimeZoneFormat::parseAbuttingAsciiOffsetFields(const UnicodeString& text, ParsePosition& pos, OffsetFields minFields, OffsetFields maxFields, UBool fixedHourWidth) {
2075 int32_t start = pos.getIndex();
2076
2077 int32_t minDigits = 2 * (minFields + 1) - (fixedHourWidth ? 0 : 1);
2078 int32_t maxDigits = 2 * (maxFields + 1);
2079
2080 U_ASSERT(maxDigits <= MAX_OFFSET_DIGITS);
2081
2082 int32_t digits[MAX_OFFSET_DIGITS] = {};
2083 int32_t numDigits = 0;
2084 int32_t idx = start;
2085 while (numDigits < maxDigits && idx < text.length()) {
2086 UChar uch = text.charAt(idx);
2087 int32_t digit = DIGIT_VAL(uch);
2088 if (digit < 0) {
2089 break;
2090 }
2091 digits[numDigits] = digit;
2092 numDigits++;
2093 idx++;
2094 }
2095
2096 if (fixedHourWidth && (numDigits & 1)) {
2097 // Fixed digits, so the number of digits must be even number. Truncating.
2098 numDigits--;
2099 }
2100
2101 if (numDigits < minDigits) {
2102 pos.setErrorIndex(start);
2103 return 0;
2104 }
2105
2106 int32_t hour = 0, min = 0, sec = 0;
2107 UBool bParsed = FALSE;
2108 while (numDigits >= minDigits) {
2109 switch (numDigits) {
2110 case 1: //H
2111 hour = digits[0];
2112 break;
2113 case 2: //HH
2114 hour = digits[0] * 10 + digits[1];
2115 break;
2116 case 3: //Hmm
2117 hour = digits[0];
2118 min = digits[1] * 10 + digits[2];
2119 break;
2120 case 4: //HHmm
2121 hour = digits[0] * 10 + digits[1];
2122 min = digits[2] * 10 + digits[3];
2123 break;
2124 case 5: //Hmmss
2125 hour = digits[0];
2126 min = digits[1] * 10 + digits[2];
2127 sec = digits[3] * 10 + digits[4];
2128 break;
2129 case 6: //HHmmss
2130 hour = digits[0] * 10 + digits[1];
2131 min = digits[2] * 10 + digits[3];
2132 sec = digits[4] * 10 + digits[5];
2133 break;
2134 }
2135
2136 if (hour <= MAX_OFFSET_HOUR && min <= MAX_OFFSET_MINUTE && sec <= MAX_OFFSET_SECOND) {
2137 // Successfully parsed
2138 bParsed = true;
2139 break;
2140 }
2141
2142 // Truncating
2143 numDigits -= (fixedHourWidth ? 2 : 1);
2144 hour = min = sec = 0;
2145 }
2146
2147 if (!bParsed) {
2148 pos.setErrorIndex(start);
2149 return 0;
2150 }
2151 pos.setIndex(start + numDigits);
2152 return ((((hour * 60) + min) * 60) + sec) * 1000;
2153 }
2154
2155 int32_t
2156 TimeZoneFormat::parseAsciiOffsetFields(const UnicodeString& text, ParsePosition& pos, UChar sep, OffsetFields minFields, OffsetFields maxFields) {
2157 int32_t start = pos.getIndex();
2158 int32_t fieldVal[] = {0, 0, 0};
2159 int32_t fieldLen[] = {0, -1, -1};
2160 for (int32_t idx = start, fieldIdx = 0; idx < text.length() && fieldIdx <= maxFields; idx++) {
2161 UChar c = text.charAt(idx);
2162 if (c == sep) {
2163 if (fieldIdx == 0) {
2164 if (fieldLen[0] == 0) {
2165 // no hours field
2166 break;
2167 }
2168 // 1 digit hour, move to next field
2169 } else {
2170 if (fieldLen[fieldIdx] != -1) {
2171 // premature minute or seconds field
2172 break;
2173 }
2174 fieldLen[fieldIdx] = 0;
2175 }
2176 continue;
2177 } else if (fieldLen[fieldIdx] == -1) {
2178 // no separator after 2 digit field
2179 break;
2180 }
2181 int32_t digit = DIGIT_VAL(c);
2182 if (digit < 0) {
2183 // not a digit
2184 break;
2185 }
2186 fieldVal[fieldIdx] = fieldVal[fieldIdx] * 10 + digit;
2187 fieldLen[fieldIdx]++;
2188 if (fieldLen[fieldIdx] >= 2) {
2189 // parsed 2 digits, move to next field
2190 fieldIdx++;
2191 }
2192 }
2193
2194 int32_t offset = 0;
2195 int32_t parsedLen = 0;
2196 int32_t parsedFields = -1;
2197 do {
2198 // hour
2199 if (fieldLen[0] == 0) {
2200 break;
2201 }
2202 if (fieldVal[0] > MAX_OFFSET_HOUR) {
2203 offset = (fieldVal[0] / 10) * MILLIS_PER_HOUR;
2204 parsedFields = FIELDS_H;
2205 parsedLen = 1;
2206 break;
2207 }
2208 offset = fieldVal[0] * MILLIS_PER_HOUR;
2209 parsedLen = fieldLen[0];
2210 parsedFields = FIELDS_H;
2211
2212 // minute
2213 if (fieldLen[1] != 2 || fieldVal[1] > MAX_OFFSET_MINUTE) {
2214 break;
2215 }
2216 offset += fieldVal[1] * MILLIS_PER_MINUTE;
2217 parsedLen += (1 + fieldLen[1]);
2218 parsedFields = FIELDS_HM;
2219
2220 // second
2221 if (fieldLen[2] != 2 || fieldVal[2] > MAX_OFFSET_SECOND) {
2222 break;
2223 }
2224 offset += fieldVal[2] * MILLIS_PER_SECOND;
2225 parsedLen += (1 + fieldLen[2]);
2226 parsedFields = FIELDS_HMS;
2227 } while (false);
2228
2229 if (parsedFields < minFields) {
2230 pos.setErrorIndex(start);
2231 return 0;
2232 }
2233
2234 pos.setIndex(start + parsedLen);
2235 return offset;
2236 }
2237
2238 void
2239 TimeZoneFormat::appendOffsetDigits(UnicodeString& buf, int32_t n, uint8_t minDigits) const {
2240 U_ASSERT(n >= 0 && n < 60);
2241 int32_t numDigits = n >= 10 ? 2 : 1;
2242 for (int32_t i = 0; i < minDigits - numDigits; i++) {
2243 buf.append(fGMTOffsetDigits[0]);
2244 }
2245 if (numDigits == 2) {
2246 buf.append(fGMTOffsetDigits[n / 10]);
2247 }
2248 buf.append(fGMTOffsetDigits[n % 10]);
2249 }
2250
2251 // ------------------------------------------------------------------
2252 // Private misc
2253 void
2254 TimeZoneFormat::initGMTPattern(const UnicodeString& gmtPattern, UErrorCode& status) {
2255 if (U_FAILURE(status)) {
2256 return;
2257 }
2258 // This implementation not perfect, but sufficient practically.
2259 int32_t idx = gmtPattern.indexOf(ARG0, ARG0_LEN, 0);
2260 if (idx < 0) {
2261 status = U_ILLEGAL_ARGUMENT_ERROR;
2262 return;
2263 }
2264 fGMTPattern.setTo(gmtPattern);
2265 unquote(gmtPattern.tempSubString(0, idx), fGMTPatternPrefix);
2266 unquote(gmtPattern.tempSubString(idx + ARG0_LEN), fGMTPatternSuffix);
2267 }
2268
2269 UnicodeString&
2270 TimeZoneFormat::unquote(const UnicodeString& pattern, UnicodeString& result) {
2271 if (pattern.indexOf(SINGLEQUOTE) < 0) {
2272 result.setTo(pattern);
2273 return result;
2274 }
2275 result.remove();
2276 UBool isPrevQuote = FALSE;
2277 UBool inQuote = FALSE;
2278 for (int32_t i = 0; i < pattern.length(); i++) {
2279 UChar c = pattern.charAt(i);
2280 if (c == SINGLEQUOTE) {
2281 if (isPrevQuote) {
2282 result.append(c);
2283 isPrevQuote = FALSE;
2284 } else {
2285 isPrevQuote = TRUE;
2286 }
2287 inQuote = !inQuote;
2288 } else {
2289 isPrevQuote = FALSE;
2290 result.append(c);
2291 }
2292 }
2293 return result;
2294 }
2295
2296 UVector*
2297 TimeZoneFormat::parseOffsetPattern(const UnicodeString& pattern, OffsetFields required, UErrorCode& status) {
2298 if (U_FAILURE(status)) {
2299 return NULL;
2300 }
2301 UVector* result = new UVector(deleteGMTOffsetField, NULL, status);
2302 if (result == NULL) {
2303 status = U_MEMORY_ALLOCATION_ERROR;
2304 return NULL;
2305 }
2306
2307 int32_t checkBits = 0;
2308 UBool isPrevQuote = FALSE;
2309 UBool inQuote = FALSE;
2310 UnicodeString text;
2311 GMTOffsetField::FieldType itemType = GMTOffsetField::TEXT;
2312 int32_t itemLength = 1;
2313
2314 for (int32_t i = 0; i < pattern.length(); i++) {
2315 UChar ch = pattern.charAt(i);
2316 if (ch == SINGLEQUOTE) {
2317 if (isPrevQuote) {
2318 text.append(SINGLEQUOTE);
2319 isPrevQuote = FALSE;
2320 } else {
2321 isPrevQuote = TRUE;
2322 if (itemType != GMTOffsetField::TEXT) {
2323 if (GMTOffsetField::isValid(itemType, itemLength)) {
2324 GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, (uint8_t)itemLength, status);
2325 result->addElement(fld, status);
2326 if (U_FAILURE(status)) {
2327 break;
2328 }
2329 } else {
2330 status = U_ILLEGAL_ARGUMENT_ERROR;
2331 break;
2332 }
2333 itemType = GMTOffsetField::TEXT;
2334 }
2335 }
2336 inQuote = !inQuote;
2337 } else {
2338 isPrevQuote = FALSE;
2339 if (inQuote) {
2340 text.append(ch);
2341 } else {
2342 GMTOffsetField::FieldType tmpType = GMTOffsetField::getTypeByLetter(ch);
2343 if (tmpType != GMTOffsetField::TEXT) {
2344 // an offset time pattern character
2345 if (tmpType == itemType) {
2346 itemLength++;
2347 } else {
2348 if (itemType == GMTOffsetField::TEXT) {
2349 if (text.length() > 0) {
2350 GMTOffsetField* textfld = GMTOffsetField::createText(text, status);
2351 result->addElement(textfld, status);
2352 if (U_FAILURE(status)) {
2353 break;
2354 }
2355 text.remove();
2356 }
2357 } else {
2358 if (GMTOffsetField::isValid(itemType, itemLength)) {
2359 GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, itemLength, status);
2360 result->addElement(fld, status);
2361 if (U_FAILURE(status)) {
2362 break;
2363 }
2364 } else {
2365 status = U_ILLEGAL_ARGUMENT_ERROR;
2366 break;
2367 }
2368 }
2369 itemType = tmpType;
2370 itemLength = 1;
2371 checkBits |= tmpType;
2372 }
2373 } else {
2374 // a string literal
2375 if (itemType != GMTOffsetField::TEXT) {
2376 if (GMTOffsetField::isValid(itemType, itemLength)) {
2377 GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, itemLength, status);
2378 result->addElement(fld, status);
2379 if (U_FAILURE(status)) {
2380 break;
2381 }
2382 } else {
2383 status = U_ILLEGAL_ARGUMENT_ERROR;
2384 break;
2385 }
2386 itemType = GMTOffsetField::TEXT;
2387 }
2388 text.append(ch);
2389 }
2390 }
2391 }
2392 }
2393 // handle last item
2394 if (U_SUCCESS(status)) {
2395 if (itemType == GMTOffsetField::TEXT) {
2396 if (text.length() > 0) {
2397 GMTOffsetField* tfld = GMTOffsetField::createText(text, status);
2398 result->addElement(tfld, status);
2399 }
2400 } else {
2401 if (GMTOffsetField::isValid(itemType, itemLength)) {
2402 GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, itemLength, status);
2403 result->addElement(fld, status);
2404 } else {
2405 status = U_ILLEGAL_ARGUMENT_ERROR;
2406 }
2407 }
2408
2409 // Check all required fields are set
2410 if (U_SUCCESS(status)) {
2411 int32_t reqBits = 0;
2412 switch (required) {
2413 case FIELDS_H:
2414 reqBits = GMTOffsetField::HOUR;
2415 break;
2416 case FIELDS_HM:
2417 reqBits = GMTOffsetField::HOUR | GMTOffsetField::MINUTE;
2418 break;
2419 case FIELDS_HMS:
2420 reqBits = GMTOffsetField::HOUR | GMTOffsetField::MINUTE | GMTOffsetField::SECOND;
2421 break;
2422 }
2423 if (checkBits == reqBits) {
2424 // all required fields are set, no extra fields
2425 return result;
2426 }
2427 }
2428 }
2429
2430 // error
2431 delete result;
2432 return NULL;
2433 }
2434
2435 UnicodeString&
2436 TimeZoneFormat::expandOffsetPattern(const UnicodeString& offsetHM, UnicodeString& result, UErrorCode& status) {
2437 result.setToBogus();
2438 if (U_FAILURE(status)) {
2439 return result;
2440 }
2441 U_ASSERT(u_strlen(DEFAULT_GMT_OFFSET_MINUTE_PATTERN) == 2);
2442
2443 int32_t idx_mm = offsetHM.indexOf(DEFAULT_GMT_OFFSET_MINUTE_PATTERN, 2, 0);
2444 if (idx_mm < 0) {
2445 // Bad time zone hour pattern data
2446 status = U_ILLEGAL_ARGUMENT_ERROR;
2447 return result;
2448 }
2449
2450 UnicodeString sep;
2451 int32_t idx_H = offsetHM.tempSubString(0, idx_mm).lastIndexOf((UChar)0x0048 /* H */);
2452 if (idx_H >= 0) {
2453 sep = offsetHM.tempSubString(idx_H + 1, idx_mm - (idx_H + 1));
2454 }
2455 result.setTo(offsetHM.tempSubString(0, idx_mm + 2));
2456 result.append(sep);
2457 result.append(DEFAULT_GMT_OFFSET_SECOND_PATTERN, -1);
2458 result.append(offsetHM.tempSubString(idx_mm + 2));
2459 return result;
2460 }
2461
2462 UnicodeString&
2463 TimeZoneFormat::truncateOffsetPattern(const UnicodeString& offsetHM, UnicodeString& result, UErrorCode& status) {
2464 result.setToBogus();
2465 if (U_FAILURE(status)) {
2466 return result;
2467 }
2468 U_ASSERT(u_strlen(DEFAULT_GMT_OFFSET_MINUTE_PATTERN) == 2);
2469
2470 int32_t idx_mm = offsetHM.indexOf(DEFAULT_GMT_OFFSET_MINUTE_PATTERN, 2, 0);
2471 if (idx_mm < 0) {
2472 // Bad time zone hour pattern data
2473 status = U_ILLEGAL_ARGUMENT_ERROR;
2474 return result;
2475 }
2476 UChar HH[] = {0x0048, 0x0048};
2477 int32_t idx_HH = offsetHM.tempSubString(0, idx_mm).lastIndexOf(HH, 2, 0);
2478 if (idx_HH >= 0) {
2479 return result.setTo(offsetHM.tempSubString(0, idx_HH + 2));
2480 }
2481 int32_t idx_H = offsetHM.tempSubString(0, idx_mm).lastIndexOf((UChar)0x0048, 0);
2482 if (idx_H >= 0) {
2483 return result.setTo(offsetHM.tempSubString(0, idx_H + 1));
2484 }
2485 // Bad time zone hour pattern data
2486 status = U_ILLEGAL_ARGUMENT_ERROR;
2487 return result;
2488 }
2489
2490 void
2491 TimeZoneFormat::initGMTOffsetPatterns(UErrorCode& status) {
2492 for (int32_t type = 0; type < UTZFMT_PAT_COUNT; type++) {
2493 switch (type) {
2494 case UTZFMT_PAT_POSITIVE_H:
2495 case UTZFMT_PAT_NEGATIVE_H:
2496 fGMTOffsetPatternItems[type] = parseOffsetPattern(fGMTOffsetPatterns[type], FIELDS_H, status);
2497 break;
2498 case UTZFMT_PAT_POSITIVE_HM:
2499 case UTZFMT_PAT_NEGATIVE_HM:
2500 fGMTOffsetPatternItems[type] = parseOffsetPattern(fGMTOffsetPatterns[type], FIELDS_HM, status);
2501 break;
2502 case UTZFMT_PAT_POSITIVE_HMS:
2503 case UTZFMT_PAT_NEGATIVE_HMS:
2504 fGMTOffsetPatternItems[type] = parseOffsetPattern(fGMTOffsetPatterns[type], FIELDS_HMS, status);
2505 break;
2506 }
2507 }
2508 checkAbuttingHoursAndMinutes();
2509 }
2510
2511 void
2512 TimeZoneFormat::checkAbuttingHoursAndMinutes() {
2513 fAbuttingOffsetHoursAndMinutes= FALSE;
2514 for (int32_t type = 0; type < UTZFMT_PAT_COUNT; type++) {
2515 UBool afterH = FALSE;
2516 UVector *items = fGMTOffsetPatternItems[type];
2517 for (int32_t i = 0; i < items->size(); i++) {
2518 const GMTOffsetField* item = (GMTOffsetField*)items->elementAt(i);
2519 GMTOffsetField::FieldType type = item->getType();
2520 if (type != GMTOffsetField::TEXT) {
2521 if (afterH) {
2522 fAbuttingOffsetHoursAndMinutes = TRUE;
2523 break;
2524 } else if (type == GMTOffsetField::HOUR) {
2525 afterH = TRUE;
2526 }
2527 } else if (afterH) {
2528 break;
2529 }
2530 }
2531 if (fAbuttingOffsetHoursAndMinutes) {
2532 break;
2533 }
2534 }
2535 }
2536
2537 UBool
2538 TimeZoneFormat::toCodePoints(const UnicodeString& str, UChar32* codeArray, int32_t size) {
2539 int32_t count = str.countChar32();
2540 if (count != size) {
2541 return FALSE;
2542 }
2543
2544 for (int32_t idx = 0, start = 0; idx < size; idx++) {
2545 codeArray[idx] = str.char32At(start);
2546 start = str.moveIndex32(start, 1);
2547 }
2548
2549 return TRUE;
2550 }
2551
2552 TimeZone*
2553 TimeZoneFormat::createTimeZoneForOffset(int32_t offset) const {
2554 if (offset == 0) {
2555 // when offset is 0, we should use "Etc/GMT"
2556 return TimeZone::createTimeZone(UnicodeString(TZID_GMT));
2557 }
2558 return ZoneMeta::createCustomTimeZone(offset);
2559 }
2560
2561 UTimeZoneFormatTimeType
2562 TimeZoneFormat::getTimeType(UTimeZoneNameType nameType) {
2563 switch (nameType) {
2564 case UTZNM_LONG_STANDARD:
2565 case UTZNM_SHORT_STANDARD:
2566 return UTZFMT_TIME_TYPE_STANDARD;
2567
2568 case UTZNM_LONG_DAYLIGHT:
2569 case UTZNM_SHORT_DAYLIGHT:
2570 return UTZFMT_TIME_TYPE_DAYLIGHT;
2571
2572 default:
2573 U_ASSERT(FALSE);
2574 }
2575 return UTZFMT_TIME_TYPE_UNKNOWN;
2576 }
2577
2578 UnicodeString&
2579 TimeZoneFormat::getTimeZoneID(const TimeZoneNames::MatchInfoCollection* matches, int32_t idx, UnicodeString& tzID) const {
2580 if (!matches->getTimeZoneIDAt(idx, tzID)) {
2581 UnicodeString mzID;
2582 if (matches->getMetaZoneIDAt(idx, mzID)) {
2583 fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, tzID);
2584 }
2585 }
2586 return tzID;
2587 }
2588
2589
2590 class ZoneIdMatchHandler : public TextTrieMapSearchResultHandler {
2591 public:
2592 ZoneIdMatchHandler();
2593 virtual ~ZoneIdMatchHandler();
2594
2595 UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status);
2596 const UChar* getID();
2597 int32_t getMatchLen();
2598 private:
2599 int32_t fLen;
2600 const UChar* fID;
2601 };
2602
2603 ZoneIdMatchHandler::ZoneIdMatchHandler()
2604 : fLen(0), fID(NULL) {
2605 }
2606
2607 ZoneIdMatchHandler::~ZoneIdMatchHandler() {
2608 }
2609
2610 UBool
2611 ZoneIdMatchHandler::handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status) {
2612 if (U_FAILURE(status)) {
2613 return FALSE;
2614 }
2615 if (node->hasValues()) {
2616 const UChar* id = (const UChar*)node->getValue(0);
2617 if (id != NULL) {
2618 if (fLen < matchLength) {
2619 fID = id;
2620 fLen = matchLength;
2621 }
2622 }
2623 }
2624 return TRUE;
2625 }
2626
2627 const UChar*
2628 ZoneIdMatchHandler::getID() {
2629 return fID;
2630 }
2631
2632 int32_t
2633 ZoneIdMatchHandler::getMatchLen() {
2634 return fLen;
2635 }
2636
2637 UnicodeString&
2638 TimeZoneFormat::parseZoneID(const UnicodeString& text, ParsePosition& pos, UnicodeString& tzID) const {
2639 UErrorCode status = U_ZERO_ERROR;
2640 UBool initialized;
2641 UMTX_CHECK(&gLock, gZoneIdTrieInitialized, initialized);
2642 if (!initialized) {
2643 umtx_lock(&gLock);
2644 {
2645 if (!gZoneIdTrieInitialized) {
2646 StringEnumeration *tzenum = TimeZone::createEnumeration();
2647 TextTrieMap* trie = new TextTrieMap(TRUE, NULL); // No deleter, because values are pooled by ZoneMeta
2648 if (trie) {
2649 const UnicodeString *id;
2650 while ((id = tzenum->snext(status))) {
2651 const UChar* uid = ZoneMeta::findTimeZoneID(*id);
2652 if (uid) {
2653 trie->put(uid, const_cast<UChar *>(uid), status);
2654 }
2655 }
2656 if (U_SUCCESS(status)) {
2657 gZoneIdTrie = trie;
2658 gZoneIdTrieInitialized = initialized = TRUE;
2659 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONEFORMAT, tzfmt_cleanup);
2660 } else {
2661 delete trie;
2662 }
2663 }
2664 delete tzenum;
2665 }
2666 }
2667 umtx_unlock(&gLock);
2668 }
2669
2670 int32_t start = pos.getIndex();
2671 int32_t len = 0;
2672 tzID.setToBogus();
2673
2674 if (initialized) {
2675 LocalPointer<ZoneIdMatchHandler> handler(new ZoneIdMatchHandler());
2676 gZoneIdTrie->search(text, start, handler.getAlias(), status);
2677 len = handler->getMatchLen();
2678 if (len > 0) {
2679 tzID.setTo(handler->getID(), -1);
2680 }
2681 }
2682
2683 if (len > 0) {
2684 pos.setIndex(start + len);
2685 } else {
2686 pos.setErrorIndex(start);
2687 }
2688
2689 return tzID;
2690 }
2691
2692 UnicodeString&
2693 TimeZoneFormat::parseShortZoneID(const UnicodeString& text, ParsePosition& pos, UnicodeString& tzID) const {
2694 UErrorCode status = U_ZERO_ERROR;
2695 UBool initialized;
2696 UMTX_CHECK(&gLock, gShortZoneIdTrieInitialized, initialized);
2697 if (!initialized) {
2698 umtx_lock(&gLock);
2699 {
2700 if (!gShortZoneIdTrieInitialized) {
2701 StringEnumeration *tzenum = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL, NULL, NULL, status);
2702 if (U_SUCCESS(status)) {
2703 TextTrieMap* trie = new TextTrieMap(TRUE, NULL); // No deleter, because values are pooled by ZoneMeta
2704 if (trie) {
2705 const UnicodeString *id;
2706 while ((id = tzenum->snext(status))) {
2707 const UChar* uID = ZoneMeta::findTimeZoneID(*id);
2708 const UChar* shortID = ZoneMeta::getShortID(*id);
2709 if (shortID && uID) {
2710 trie->put(shortID, const_cast<UChar *>(uID), status);
2711 }
2712 }
2713 if (U_SUCCESS(status)) {
2714 gShortZoneIdTrie = trie;
2715 gShortZoneIdTrieInitialized = initialized = TRUE;
2716 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONEFORMAT, tzfmt_cleanup);
2717 } else {
2718 delete trie;
2719 }
2720 }
2721 }
2722 delete tzenum;
2723 }
2724 }
2725 umtx_unlock(&gLock);
2726 }
2727
2728 int32_t start = pos.getIndex();
2729 int32_t len = 0;
2730 tzID.setToBogus();
2731
2732 if (initialized) {
2733 LocalPointer<ZoneIdMatchHandler> handler(new ZoneIdMatchHandler());
2734 gShortZoneIdTrie->search(text, start, handler.getAlias(), status);
2735 len = handler->getMatchLen();
2736 if (len > 0) {
2737 tzID.setTo(handler->getID(), -1);
2738 }
2739 }
2740
2741 if (len > 0) {
2742 pos.setIndex(start + len);
2743 } else {
2744 pos.setErrorIndex(start);
2745 }
2746
2747 return tzID;
2748 }
2749
2750
2751 UnicodeString&
2752 TimeZoneFormat::parseExemplarLocation(const UnicodeString& text, ParsePosition& pos, UnicodeString& tzID) const {
2753 int32_t startIdx = pos.getIndex();
2754 int32_t parsedPos = -1;
2755 tzID.setToBogus();
2756
2757 UErrorCode status = U_ZERO_ERROR;
2758 LocalPointer<TimeZoneNames::MatchInfoCollection> exemplarMatches(fTimeZoneNames->find(text, startIdx, UTZNM_EXEMPLAR_LOCATION, status));
2759 if (U_FAILURE(status)) {
2760 pos.setErrorIndex(startIdx);
2761 return tzID;
2762 }
2763 int32_t matchIdx = -1;
2764 if (!exemplarMatches.isNull()) {
2765 for (int32_t i = 0; i < exemplarMatches->size(); i++) {
2766 if (startIdx + exemplarMatches->getMatchLengthAt(i) > parsedPos) {
2767 matchIdx = i;
2768 parsedPos = startIdx + exemplarMatches->getMatchLengthAt(i);
2769 }
2770 }
2771 if (parsedPos > 0) {
2772 pos.setIndex(parsedPos);
2773 getTimeZoneID(exemplarMatches.getAlias(), matchIdx, tzID);
2774 }
2775 }
2776
2777 if (tzID.length() == 0) {
2778 pos.setErrorIndex(startIdx);
2779 }
2780
2781 return tzID;
2782 }
2783
2784 U_NAMESPACE_END
2785
2786 #endif
mirror of ICU