git.saurik.com Git - apple/icu.git/blame - icuSources/i18n/tzfmt.cpp

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