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