git.saurik.com Git - apple/icu.git/blame_incremental

... / ...

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