1 /*
2 *******************************************************************************
3 * Copyright (C) 1997-2012, International Business Machines Corporation and *
4 * others. All Rights Reserved. *
5 *******************************************************************************
6 *
7 * File SMPDTFMT.CPP
8 *
9 * Modification History:
10 *
11 * Date Name Description
12 * 02/19/97 aliu Converted from java.
13 * 03/31/97 aliu Modified extensively to work with 50 locales.
14 * 04/01/97 aliu Added support for centuries.
15 * 07/09/97 helena Made ParsePosition into a class.
16 * 07/21/98 stephen Added initializeDefaultCentury.
17 * Removed getZoneIndex (added in DateFormatSymbols)
18 * Removed subParseLong
19 * Removed chk
20 * 02/22/99 stephen Removed character literals for EBCDIC safety
21 * 10/14/99 aliu Updated 2-digit year parsing so that only "00" thru
22 * "99" are recognized. {j28 4182066}
23 * 11/15/99 weiv Added support for week of year/day of week format
24 ********************************************************************************
25 */
26
27 #define ZID_KEY_MAX 128
28
29 #include "unicode/utypes.h"
30
31 #if !UCONFIG_NO_FORMATTING
32
33 #include "unicode/smpdtfmt.h"
34 #include "unicode/dtfmtsym.h"
35 #include "unicode/ures.h"
36 #include "unicode/msgfmt.h"
37 #include "unicode/calendar.h"
38 #include "unicode/gregocal.h"
39 #include "unicode/timezone.h"
40 #include "unicode/decimfmt.h"
41 #include "unicode/dcfmtsym.h"
42 #include "unicode/uchar.h"
43 #include "unicode/uniset.h"
44 #include "unicode/ustring.h"
45 #include "unicode/basictz.h"
46 #include "unicode/simpletz.h"
47 #include "unicode/rbtz.h"
48 #include "unicode/tzfmt.h"
49 #include "unicode/utf16.h"
50 #include "unicode/vtzone.h"
51 #include "unicode/udisplaycontext.h"
52 #include "olsontz.h"
53 #include "patternprops.h"
54 #include "fphdlimp.h"
55 #include "gregoimp.h"
56 #include "hebrwcal.h"
57 #include "cstring.h"
58 #include "uassert.h"
59 #include "cmemory.h"
60 #include "umutex.h"
61 #include <float.h>
62 #include "smpdtfst.h"
63
64 #if defined( U_DEBUG_CALSVC ) || defined (U_DEBUG_CAL)
65 #include <stdio.h>
66 #endif
67
68 // *****************************************************************************
69 // class SimpleDateFormat
70 // *****************************************************************************
71
72 U_NAMESPACE_BEGIN
73
74 static const UChar PATTERN_CHAR_BASE = 0x40;
75
76 /**
77 * Last-resort string to use for "GMT" when constructing time zone strings.
78 */
79 // For time zones that have no names, use strings GMT+minutes and
80 // GMT-minutes. For instance, in France the time zone is GMT+60.
81 // Also accepted are GMT+H:MM or GMT-H:MM.
82 // Currently not being used
83 //static const UChar gGmt[] = {0x0047, 0x004D, 0x0054, 0x0000}; // "GMT"
84 //static const UChar gGmtPlus[] = {0x0047, 0x004D, 0x0054, 0x002B, 0x0000}; // "GMT+"
85 //static const UChar gGmtMinus[] = {0x0047, 0x004D, 0x0054, 0x002D, 0x0000}; // "GMT-"
86 //static const UChar gDefGmtPat[] = {0x0047, 0x004D, 0x0054, 0x007B, 0x0030, 0x007D, 0x0000}; /* GMT{0} */
87 //static const UChar gDefGmtNegHmsPat[] = {0x002D, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0x0000}; /* -HH:mm:ss */
88 //static const UChar gDefGmtNegHmPat[] = {0x002D, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x0000}; /* -HH:mm */
89 //static const UChar gDefGmtPosHmsPat[] = {0x002B, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0x0000}; /* +HH:mm:ss */
90 //static const UChar gDefGmtPosHmPat[] = {0x002B, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x0000}; /* +HH:mm */
91 //static const UChar gUt[] = {0x0055, 0x0054, 0x0000}; // "UT"
92 //static const UChar gUtc[] = {0x0055, 0x0054, 0x0043, 0x0000}; // "UT"
93
94 typedef enum GmtPatSize {
95 kGmtLen = 3,
96 kGmtPatLen = 6,
97 kNegHmsLen = 9,
98 kNegHmLen = 6,
99 kPosHmsLen = 9,
100 kPosHmLen = 6,
101 kUtLen = 2,
102 kUtcLen = 3
103 } GmtPatSize;
104
105 // Stuff needed for numbering system overrides
106
107 typedef enum OvrStrType {
108 kOvrStrDate = 0,
109 kOvrStrTime = 1,
110 kOvrStrBoth = 2
111 } OvrStrType;
112
113 static const UDateFormatField kDateFields[] = {
114 UDAT_YEAR_FIELD,
115 UDAT_MONTH_FIELD,
116 UDAT_DATE_FIELD,
117 UDAT_DAY_OF_YEAR_FIELD,
118 UDAT_DAY_OF_WEEK_IN_MONTH_FIELD,
119 UDAT_WEEK_OF_YEAR_FIELD,
120 UDAT_WEEK_OF_MONTH_FIELD,
121 UDAT_YEAR_WOY_FIELD,
122 UDAT_EXTENDED_YEAR_FIELD,
123 UDAT_JULIAN_DAY_FIELD,
124 UDAT_STANDALONE_DAY_FIELD,
125 UDAT_STANDALONE_MONTH_FIELD,
126 UDAT_QUARTER_FIELD,
127 UDAT_STANDALONE_QUARTER_FIELD,
128 UDAT_YEAR_NAME_FIELD };
129 static const int8_t kDateFieldsCount = 15;
130
131 static const UDateFormatField kTimeFields[] = {
132 UDAT_HOUR_OF_DAY1_FIELD,
133 UDAT_HOUR_OF_DAY0_FIELD,
134 UDAT_MINUTE_FIELD,
135 UDAT_SECOND_FIELD,
136 UDAT_FRACTIONAL_SECOND_FIELD,
137 UDAT_HOUR1_FIELD,
138 UDAT_HOUR0_FIELD,
139 UDAT_MILLISECONDS_IN_DAY_FIELD,
140 UDAT_TIMEZONE_RFC_FIELD };
141 static const int8_t kTimeFieldsCount = 9;
142
143
144 // This is a pattern-of-last-resort used when we can't load a usable pattern out
145 // of a resource.
146 static const UChar gDefaultPattern[] =
147 {
148 0x79, 0x79, 0x79, 0x79, 0x4D, 0x4D, 0x64, 0x64, 0x20, 0x68, 0x68, 0x3A, 0x6D, 0x6D, 0x20, 0x61, 0
149 }; /* "yyyyMMdd hh:mm a" */
150
151 // This prefix is designed to NEVER MATCH real text, in order to
152 // suppress the parsing of negative numbers. Adjust as needed (if
153 // this becomes valid Unicode).
154 static const UChar SUPPRESS_NEGATIVE_PREFIX[] = {0xAB00, 0};
155
156 /**
157 * These are the tags we expect to see in normal resource bundle files associated
158 * with a locale.
159 */
160 static const char gDateTimePatternsTag[]="DateTimePatterns";
161
162 //static const UChar gEtcUTC[] = {0x45, 0x74, 0x63, 0x2F, 0x55, 0x54, 0x43, 0x00}; // "Etc/UTC"
163 static const UChar QUOTE = 0x27; // Single quote
164
165 /*
166 * The field range check bias for each UDateFormatField.
167 * The bias is added to the minimum and maximum values
168 * before they are compared to the parsed number.
169 * For example, the calendar stores zero-based month numbers
170 * but the parsed month numbers start at 1, so the bias is 1.
171 *
172 * A value of -1 means that the value is not checked.
173 */
174 static const int32_t gFieldRangeBias[] = {
175 -1, // 'G' - UDAT_ERA_FIELD
176 -1, // 'y' - UDAT_YEAR_FIELD
177 1, // 'M' - UDAT_MONTH_FIELD
178 0, // 'd' - UDAT_DATE_FIELD
179 -1, // 'k' - UDAT_HOUR_OF_DAY1_FIELD
180 -1, // 'H' - UDAT_HOUR_OF_DAY0_FIELD
181 0, // 'm' - UDAT_MINUTE_FIELD
182 0, // 's' - UDAT_SEOND_FIELD
183 -1, // 'S' - UDAT_FRACTIONAL_SECOND_FIELD (0-999?)
184 -1, // 'E' - UDAT_DAY_OF_WEEK_FIELD (1-7?)
185 -1, // 'D' - UDAT_DAY_OF_YEAR_FIELD (1 - 366?)
186 -1, // 'F' - UDAT_DAY_OF_WEEK_IN_MONTH_FIELD (1-5?)
187 -1, // 'w' - UDAT_WEEK_OF_YEAR_FIELD (1-52?)
188 -1, // 'W' - UDAT_WEEK_OF_MONTH_FIELD (1-5?)
189 -1, // 'a' - UDAT_AM_PM_FIELD
190 -1, // 'h' - UDAT_HOUR1_FIELD
191 -1, // 'K' - UDAT_HOUR0_FIELD
192 -1, // 'z' - UDAT_TIMEZONE_FIELD
193 -1, // 'Y' - UDAT_YEAR_WOY_FIELD
194 -1, // 'e' - UDAT_DOW_LOCAL_FIELD
195 -1, // 'u' - UDAT_EXTENDED_YEAR_FIELD
196 -1, // 'g' - UDAT_JULIAN_DAY_FIELD
197 -1, // 'A' - UDAT_MILLISECONDS_IN_DAY_FIELD
198 -1, // 'Z' - UDAT_TIMEZONE_RFC_FIELD
199 -1, // 'v' - UDAT_TIMEZONE_GENERIC_FIELD
200 0, // 'c' - UDAT_STANDALONE_DAY_FIELD
201 1, // 'L' - UDAT_STANDALONE_MONTH_FIELD
202 -1, // 'Q' - UDAT_QUARTER_FIELD (1-4?)
203 -1, // 'q' - UDAT_STANDALONE_QUARTER_FIELD
204 -1 // 'V' - UDAT_TIMEZONE_SPECIAL_FIELD
205 -1, // 'U' - UDAT_YEAR_NAME_FIELD
206 };
207
208 // When calendar uses hebr numbering (i.e. he@calendar=hebrew),
209 // offset the years within the current millenium down to 1-999
210 static const int32_t HEBREW_CAL_CUR_MILLENIUM_START_YEAR = 5000;
211 static const int32_t HEBREW_CAL_CUR_MILLENIUM_END_YEAR = 6000;
212
213 static UMutex LOCK = U_MUTEX_INITIALIZER;
214
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SimpleDateFormat)215 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SimpleDateFormat)
216
217 //----------------------------------------------------------------------
218
219 SimpleDateFormat::~SimpleDateFormat()
220 {
221 delete fSymbols;
222 if (fNumberFormatters) {
223 uprv_free(fNumberFormatters);
224 }
225 if (fTimeZoneFormat) {
226 delete fTimeZoneFormat;
227 }
228
229 while (fOverrideList) {
230 NSOverride *cur = fOverrideList;
231 fOverrideList = cur->next;
232 delete cur->nf;
233 uprv_free(cur);
234 }
235 }
236
237 //----------------------------------------------------------------------
238
SimpleDateFormat(UErrorCode & status)239 SimpleDateFormat::SimpleDateFormat(UErrorCode& status)
240 : fLocale(Locale::getDefault()),
241 fSymbols(NULL),
242 fTimeZoneFormat(NULL),
243 fNumberFormatters(NULL),
244 fOverrideList(NULL),
245 fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
246 {
247 construct(kShort, (EStyle) (kShort + kDateOffset), fLocale, status);
248 initializeDefaultCentury();
249 }
250
251 //----------------------------------------------------------------------
252
SimpleDateFormat(const UnicodeString & pattern,UErrorCode & status)253 SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern,
254 UErrorCode &status)
255 : fPattern(pattern),
256 fLocale(Locale::getDefault()),
257 fSymbols(NULL),
258 fTimeZoneFormat(NULL),
259 fNumberFormatters(NULL),
260 fOverrideList(NULL),
261 fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
262 {
263 fDateOverride.setToBogus();
264 fTimeOverride.setToBogus();
265 initializeSymbols(fLocale, initializeCalendar(NULL,fLocale,status), status);
266 initialize(fLocale, status);
267 initializeDefaultCentury();
268
269 }
270 //----------------------------------------------------------------------
271
SimpleDateFormat(const UnicodeString & pattern,const UnicodeString & override,UErrorCode & status)272 SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern,
273 const UnicodeString& override,
274 UErrorCode &status)
275 : fPattern(pattern),
276 fLocale(Locale::getDefault()),
277 fSymbols(NULL),
278 fTimeZoneFormat(NULL),
279 fNumberFormatters(NULL),
280 fOverrideList(NULL),
281 fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
282 {
283 fDateOverride.setTo(override);
284 fTimeOverride.setToBogus();
285 initializeSymbols(fLocale, initializeCalendar(NULL,fLocale,status), status);
286 initialize(fLocale, status);
287 initializeDefaultCentury();
288
289 processOverrideString(fLocale,override,kOvrStrBoth,status);
290
291 }
292
293 //----------------------------------------------------------------------
294
SimpleDateFormat(const UnicodeString & pattern,const Locale & locale,UErrorCode & status)295 SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern,
296 const Locale& locale,
297 UErrorCode& status)
298 : fPattern(pattern),
299 fLocale(locale),
300 fTimeZoneFormat(NULL),
301 fNumberFormatters(NULL),
302 fOverrideList(NULL),
303 fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
304 {
305
306 fDateOverride.setToBogus();
307 fTimeOverride.setToBogus();
308
309 initializeSymbols(fLocale, initializeCalendar(NULL,fLocale,status), status);
310 initialize(fLocale, status);
311 initializeDefaultCentury();
312 }
313
314 //----------------------------------------------------------------------
315
SimpleDateFormat(const UnicodeString & pattern,const UnicodeString & override,const Locale & locale,UErrorCode & status)316 SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern,
317 const UnicodeString& override,
318 const Locale& locale,
319 UErrorCode& status)
320 : fPattern(pattern),
321 fLocale(locale),
322 fTimeZoneFormat(NULL),
323 fNumberFormatters(NULL),
324 fOverrideList(NULL),
325 fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
326 {
327
328 fDateOverride.setTo(override);
329 fTimeOverride.setToBogus();
330
331 initializeSymbols(fLocale, initializeCalendar(NULL,fLocale,status), status);
332 initialize(fLocale, status);
333 initializeDefaultCentury();
334
335 processOverrideString(locale,override,kOvrStrBoth,status);
336
337 }
338
339 //----------------------------------------------------------------------
340
SimpleDateFormat(const UnicodeString & pattern,DateFormatSymbols * symbolsToAdopt,UErrorCode & status)341 SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern,
342 DateFormatSymbols* symbolsToAdopt,
343 UErrorCode& status)
344 : fPattern(pattern),
345 fLocale(Locale::getDefault()),
346 fSymbols(symbolsToAdopt),
347 fTimeZoneFormat(NULL),
348 fNumberFormatters(NULL),
349 fOverrideList(NULL),
350 fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
351 {
352
353 fDateOverride.setToBogus();
354 fTimeOverride.setToBogus();
355
356 initializeCalendar(NULL,fLocale,status);
357 initialize(fLocale, status);
358 initializeDefaultCentury();
359 }
360
361 //----------------------------------------------------------------------
362
SimpleDateFormat(const UnicodeString & pattern,const DateFormatSymbols & symbols,UErrorCode & status)363 SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern,
364 const DateFormatSymbols& symbols,
365 UErrorCode& status)
366 : fPattern(pattern),
367 fLocale(Locale::getDefault()),
368 fSymbols(new DateFormatSymbols(symbols)),
369 fTimeZoneFormat(NULL),
370 fNumberFormatters(NULL),
371 fOverrideList(NULL),
372 fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
373 {
374
375 fDateOverride.setToBogus();
376 fTimeOverride.setToBogus();
377
378 initializeCalendar(NULL, fLocale, status);
379 initialize(fLocale, status);
380 initializeDefaultCentury();
381 }
382
383 //----------------------------------------------------------------------
384
385 // Not for public consumption; used by DateFormat
SimpleDateFormat(EStyle timeStyle,EStyle dateStyle,const Locale & locale,UErrorCode & status)386 SimpleDateFormat::SimpleDateFormat(EStyle timeStyle,
387 EStyle dateStyle,
388 const Locale& locale,
389 UErrorCode& status)
390 : fLocale(locale),
391 fSymbols(NULL),
392 fTimeZoneFormat(NULL),
393 fNumberFormatters(NULL),
394 fOverrideList(NULL),
395 fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
396 {
397 construct(timeStyle, dateStyle, fLocale, status);
398 if(U_SUCCESS(status)) {
399 initializeDefaultCentury();
400 }
401 }
402
403 //----------------------------------------------------------------------
404
405 /**
406 * Not for public consumption; used by DateFormat. This constructor
407 * never fails. If the resource data is not available, it uses the
408 * the last resort symbols.
409 */
SimpleDateFormat(const Locale & locale,UErrorCode & status)410 SimpleDateFormat::SimpleDateFormat(const Locale& locale,
411 UErrorCode& status)
412 : fPattern(gDefaultPattern),
413 fLocale(locale),
414 fSymbols(NULL),
415 fTimeZoneFormat(NULL),
416 fNumberFormatters(NULL),
417 fOverrideList(NULL),
418 fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
419 {
420 if (U_FAILURE(status)) return;
421 initializeSymbols(fLocale, initializeCalendar(NULL, fLocale, status),status);
422 if (U_FAILURE(status))
423 {
424 status = U_ZERO_ERROR;
425 delete fSymbols;
426 // This constructor doesn't fail; it uses last resort data
427 fSymbols = new DateFormatSymbols(status);
428 /* test for NULL */
429 if (fSymbols == 0) {
430 status = U_MEMORY_ALLOCATION_ERROR;
431 return;
432 }
433 }
434
435 fDateOverride.setToBogus();
436 fTimeOverride.setToBogus();
437
438 initialize(fLocale, status);
439 if(U_SUCCESS(status)) {
440 initializeDefaultCentury();
441 }
442 }
443
444 //----------------------------------------------------------------------
445
SimpleDateFormat(const SimpleDateFormat & other)446 SimpleDateFormat::SimpleDateFormat(const SimpleDateFormat& other)
447 : DateFormat(other),
448 fLocale(other.fLocale),
449 fSymbols(NULL),
450 fTimeZoneFormat(NULL),
451 fNumberFormatters(NULL),
452 fOverrideList(NULL),
453 fCapitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
454 {
455 *this = other;
456 }
457
458 //----------------------------------------------------------------------
459
operator =(const SimpleDateFormat & other)460 SimpleDateFormat& SimpleDateFormat::operator=(const SimpleDateFormat& other)
461 {
462 if (this == &other) {
463 return *this;
464 }
465 DateFormat::operator=(other);
466
467 delete fSymbols;
468 fSymbols = NULL;
469
470 if (other.fSymbols)
471 fSymbols = new DateFormatSymbols(*other.fSymbols);
472
473 fDefaultCenturyStart = other.fDefaultCenturyStart;
474 fDefaultCenturyStartYear = other.fDefaultCenturyStartYear;
475 fHaveDefaultCentury = other.fHaveDefaultCentury;
476
477 fPattern = other.fPattern;
478
479 // TimeZoneFormat in ICU4C only depends on a locale for now
480 if (fLocale != other.fLocale) {
481 delete fTimeZoneFormat;
482 fTimeZoneFormat = NULL; // forces lazy instantiation with the other locale
483 fLocale = other.fLocale;
484 }
485
486 fCapitalizationContext = other.fCapitalizationContext;
487
488 return *this;
489 }
490
491 //----------------------------------------------------------------------
492
493 Format*
clone() const494 SimpleDateFormat::clone() const
495 {
496 return new SimpleDateFormat(*this);
497 }
498
499 //----------------------------------------------------------------------
500
501 UBool
operator ==(const Format & other) const502 SimpleDateFormat::operator==(const Format& other) const
503 {
504 if (DateFormat::operator==(other)) {
505 // DateFormat::operator== guarantees following cast is safe
506 SimpleDateFormat* that = (SimpleDateFormat*)&other;
507 return (fPattern == that->fPattern &&
508 fSymbols != NULL && // Check for pathological object
509 that->fSymbols != NULL && // Check for pathological object
510 *fSymbols == *that->fSymbols &&
511 fHaveDefaultCentury == that->fHaveDefaultCentury &&
512 fDefaultCenturyStart == that->fDefaultCenturyStart &&
513 fCapitalizationContext == that->fCapitalizationContext);
514 }
515 return FALSE;
516 }
517
518 //----------------------------------------------------------------------
519
construct(EStyle timeStyle,EStyle dateStyle,const Locale & locale,UErrorCode & status)520 void SimpleDateFormat::construct(EStyle timeStyle,
521 EStyle dateStyle,
522 const Locale& locale,
523 UErrorCode& status)
524 {
525 // called by several constructors to load pattern data from the resources
526 if (U_FAILURE(status)) return;
527
528 // We will need the calendar to know what type of symbols to load.
529 initializeCalendar(NULL, locale, status);
530 if (U_FAILURE(status)) return;
531
532 CalendarData calData(locale, fCalendar?fCalendar->getType():NULL, status);
533 UResourceBundle *dateTimePatterns = calData.getByKey(gDateTimePatternsTag, status);
534 UResourceBundle *currentBundle;
535
536 if (U_FAILURE(status)) return;
537
538 if (ures_getSize(dateTimePatterns) <= kDateTime)
539 {
540 status = U_INVALID_FORMAT_ERROR;
541 return;
542 }
543
544 setLocaleIDs(ures_getLocaleByType(dateTimePatterns, ULOC_VALID_LOCALE, &status),
545 ures_getLocaleByType(dateTimePatterns, ULOC_ACTUAL_LOCALE, &status));
546
547 // create a symbols object from the locale
548 initializeSymbols(locale,fCalendar, status);
549 if (U_FAILURE(status)) return;
550 /* test for NULL */
551 if (fSymbols == 0) {
552 status = U_MEMORY_ALLOCATION_ERROR;
553 return;
554 }
555
556 const UChar *resStr,*ovrStr;
557 int32_t resStrLen,ovrStrLen = 0;
558 fDateOverride.setToBogus();
559 fTimeOverride.setToBogus();
560
561 // if the pattern should include both date and time information, use the date/time
562 // pattern string as a guide to tell use how to glue together the appropriate date
563 // and time pattern strings. The actual gluing-together is handled by a convenience
564 // method on MessageFormat.
565 if ((timeStyle != kNone) && (dateStyle != kNone))
566 {
567 Formattable timeDateArray[2];
568
569 // use Formattable::adoptString() so that we can use fastCopyFrom()
570 // instead of Formattable::setString()'s unaware, safe, deep string clone
571 // see Jitterbug 2296
572
573 currentBundle = ures_getByIndex(dateTimePatterns, (int32_t)timeStyle, NULL, &status);
574 if (U_FAILURE(status)) {
575 status = U_INVALID_FORMAT_ERROR;
576 return;
577 }
578 switch (ures_getType(currentBundle)) {
579 case URES_STRING: {
580 resStr = ures_getString(currentBundle, &resStrLen, &status);
581 break;
582 }
583 case URES_ARRAY: {
584 resStr = ures_getStringByIndex(currentBundle, 0, &resStrLen, &status);
585 ovrStr = ures_getStringByIndex(currentBundle, 1, &ovrStrLen, &status);
586 fTimeOverride.setTo(TRUE, ovrStr, ovrStrLen);
587 break;
588 }
589 default: {
590 status = U_INVALID_FORMAT_ERROR;
591 ures_close(currentBundle);
592 return;
593 }
594 }
595 ures_close(currentBundle);
596
597 UnicodeString *tempus1 = new UnicodeString(TRUE, resStr, resStrLen);
598 // NULL pointer check
599 if (tempus1 == NULL) {
600 status = U_MEMORY_ALLOCATION_ERROR;
601 return;
602 }
603 timeDateArray[0].adoptString(tempus1);
604
605 currentBundle = ures_getByIndex(dateTimePatterns, (int32_t)dateStyle, NULL, &status);
606 if (U_FAILURE(status)) {
607 status = U_INVALID_FORMAT_ERROR;
608 return;
609 }
610 switch (ures_getType(currentBundle)) {
611 case URES_STRING: {
612 resStr = ures_getString(currentBundle, &resStrLen, &status);
613 break;
614 }
615 case URES_ARRAY: {
616 resStr = ures_getStringByIndex(currentBundle, 0, &resStrLen, &status);
617 ovrStr = ures_getStringByIndex(currentBundle, 1, &ovrStrLen, &status);
618 fDateOverride.setTo(TRUE, ovrStr, ovrStrLen);
619 break;
620 }
621 default: {
622 status = U_INVALID_FORMAT_ERROR;
623 ures_close(currentBundle);
624 return;
625 }
626 }
627 ures_close(currentBundle);
628
629 UnicodeString *tempus2 = new UnicodeString(TRUE, resStr, resStrLen);
630 // Null pointer check
631 if (tempus2 == NULL) {
632 status = U_MEMORY_ALLOCATION_ERROR;
633 return;
634 }
635 timeDateArray[1].adoptString(tempus2);
636
637 int32_t glueIndex = kDateTime;
638 int32_t patternsSize = ures_getSize(dateTimePatterns);
639 if (patternsSize >= (kDateTimeOffset + kShort + 1)) {
640 // Get proper date time format
641 glueIndex = (int32_t)(kDateTimeOffset + (dateStyle - kDateOffset));
642 }
643
644 resStr = ures_getStringByIndex(dateTimePatterns, glueIndex, &resStrLen, &status);
645 MessageFormat::format(UnicodeString(TRUE, resStr, resStrLen), timeDateArray, 2, fPattern, status);
646 }
647 // if the pattern includes just time data or just date date, load the appropriate
648 // pattern string from the resources
649 // setTo() - see DateFormatSymbols::assignArray comments
650 else if (timeStyle != kNone) {
651 currentBundle = ures_getByIndex(dateTimePatterns, (int32_t)timeStyle, NULL, &status);
652 if (U_FAILURE(status)) {
653 status = U_INVALID_FORMAT_ERROR;
654 return;
655 }
656 switch (ures_getType(currentBundle)) {
657 case URES_STRING: {
658 resStr = ures_getString(currentBundle, &resStrLen, &status);
659 break;
660 }
661 case URES_ARRAY: {
662 resStr = ures_getStringByIndex(currentBundle, 0, &resStrLen, &status);
663 ovrStr = ures_getStringByIndex(currentBundle, 1, &ovrStrLen, &status);
664 fDateOverride.setTo(TRUE, ovrStr, ovrStrLen);
665 break;
666 }
667 default: {
668 status = U_INVALID_FORMAT_ERROR;
669 ures_close(currentBundle);
670 return;
671 }
672 }
673 fPattern.setTo(TRUE, resStr, resStrLen);
674 ures_close(currentBundle);
675 }
676 else if (dateStyle != kNone) {
677 currentBundle = ures_getByIndex(dateTimePatterns, (int32_t)dateStyle, NULL, &status);
678 if (U_FAILURE(status)) {
679 status = U_INVALID_FORMAT_ERROR;
680 return;
681 }
682 switch (ures_getType(currentBundle)) {
683 case URES_STRING: {
684 resStr = ures_getString(currentBundle, &resStrLen, &status);
685 break;
686 }
687 case URES_ARRAY: {
688 resStr = ures_getStringByIndex(currentBundle, 0, &resStrLen, &status);
689 ovrStr = ures_getStringByIndex(currentBundle, 1, &ovrStrLen, &status);
690 fDateOverride.setTo(TRUE, ovrStr, ovrStrLen);
691 break;
692 }
693 default: {
694 status = U_INVALID_FORMAT_ERROR;
695 ures_close(currentBundle);
696 return;
697 }
698 }
699 fPattern.setTo(TRUE, resStr, resStrLen);
700 ures_close(currentBundle);
701 }
702
703 // and if it includes _neither_, that's an error
704 else
705 status = U_INVALID_FORMAT_ERROR;
706
707 // finally, finish initializing by creating a Calendar and a NumberFormat
708 initialize(locale, status);
709 }
710
711 //----------------------------------------------------------------------
712
713 Calendar*
initializeCalendar(TimeZone * adoptZone,const Locale & locale,UErrorCode & status)714 SimpleDateFormat::initializeCalendar(TimeZone* adoptZone, const Locale& locale, UErrorCode& status)
715 {
716 if(!U_FAILURE(status)) {
717 fCalendar = Calendar::createInstance(adoptZone?adoptZone:TimeZone::createDefault(), locale, status);
718 }
719 if (U_SUCCESS(status) && fCalendar == NULL) {
720 status = U_MEMORY_ALLOCATION_ERROR;
721 }
722 return fCalendar;
723 }
724
725 void
initializeSymbols(const Locale & locale,Calendar * calendar,UErrorCode & status)726 SimpleDateFormat::initializeSymbols(const Locale& locale, Calendar* calendar, UErrorCode& status)
727 {
728 if(U_FAILURE(status)) {
729 fSymbols = NULL;
730 } else {
731 // pass in calendar type - use NULL (default) if no calendar set (or err).
732 fSymbols = new DateFormatSymbols(locale, calendar?calendar->getType() :NULL , status);
733 // Null pointer check
734 if (fSymbols == NULL) {
735 status = U_MEMORY_ALLOCATION_ERROR;
736 return;
737 }
738 }
739 }
740
741 void
initialize(const Locale & locale,UErrorCode & status)742 SimpleDateFormat::initialize(const Locale& locale,
743 UErrorCode& status)
744 {
745 if (U_FAILURE(status)) return;
746
747 // We don't need to check that the row count is >= 1, since all 2d arrays have at
748 // least one row
749 fNumberFormat = NumberFormat::createInstance(locale, status);
750 if (fNumberFormat != NULL && U_SUCCESS(status))
751 {
752 // no matter what the locale's default number format looked like, we want
753 // to modify it so that it doesn't use thousands separators, doesn't always
754 // show the decimal point, and recognizes integers only when parsing
755
756 fNumberFormat->setGroupingUsed(FALSE);
757 DecimalFormat* decfmt = dynamic_cast<DecimalFormat*>(fNumberFormat);
758 if (decfmt != NULL) {
759 decfmt->setDecimalSeparatorAlwaysShown(FALSE);
760 }
761 fNumberFormat->setParseIntegerOnly(TRUE);
762 fNumberFormat->setMinimumFractionDigits(0); // To prevent "Jan 1.00, 1997.00"
763
764 //fNumberFormat->setLenient(TRUE); // Java uses a custom DateNumberFormat to format/parse
765
766 initNumberFormatters(locale,status);
767
768 }
769 else if (U_SUCCESS(status))
770 {
771 status = U_MISSING_RESOURCE_ERROR;
772 }
773 }
774
775 /* Initialize the fields we use to disambiguate ambiguous years. Separate
776 * so we can call it from readObject().
777 */
initializeDefaultCentury()778 void SimpleDateFormat::initializeDefaultCentury()
779 {
780 if(fCalendar) {
781 fHaveDefaultCentury = fCalendar->haveDefaultCentury();
782 if(fHaveDefaultCentury) {
783 fDefaultCenturyStart = fCalendar->defaultCenturyStart();
784 fDefaultCenturyStartYear = fCalendar->defaultCenturyStartYear();
785 } else {
786 fDefaultCenturyStart = DBL_MIN;
787 fDefaultCenturyStartYear = -1;
788 }
789 }
790 }
791
792 /* Define one-century window into which to disambiguate dates using
793 * two-digit years. Make public in JDK 1.2.
794 */
parseAmbiguousDatesAsAfter(UDate startDate,UErrorCode & status)795 void SimpleDateFormat::parseAmbiguousDatesAsAfter(UDate startDate, UErrorCode& status)
796 {
797 if(U_FAILURE(status)) {
798 return;
799 }
800 if(!fCalendar) {
801 status = U_ILLEGAL_ARGUMENT_ERROR;
802 return;
803 }
804
805 fCalendar->setTime(startDate, status);
806 if(U_SUCCESS(status)) {
807 fHaveDefaultCentury = TRUE;
808 fDefaultCenturyStart = startDate;
809 fDefaultCenturyStartYear = fCalendar->get(UCAL_YEAR, status);
810 }
811 }
812
813 //----------------------------------------------------------------------
814
815 UnicodeString&
format(Calendar & cal,UnicodeString & appendTo,FieldPosition & pos) const816 SimpleDateFormat::format(Calendar& cal, UnicodeString& appendTo, FieldPosition& pos) const
817 {
818 UErrorCode status = U_ZERO_ERROR;
819 FieldPositionOnlyHandler handler(pos);
820 return _format(cal, appendTo, handler, status);
821 }
822
823 //----------------------------------------------------------------------
824
825 UnicodeString&
format(Calendar & cal,UnicodeString & appendTo,FieldPositionIterator * posIter,UErrorCode & status) const826 SimpleDateFormat::format(Calendar& cal, UnicodeString& appendTo,
827 FieldPositionIterator* posIter, UErrorCode& status) const
828 {
829 FieldPositionIteratorHandler handler(posIter, status);
830 return _format(cal, appendTo, handler, status);
831 }
832
833 //----------------------------------------------------------------------
834
835 UnicodeString&
_format(Calendar & cal,UnicodeString & appendTo,FieldPositionHandler & handler,UErrorCode & status) const836 SimpleDateFormat::_format(Calendar& cal, UnicodeString& appendTo,
837 FieldPositionHandler& handler, UErrorCode& status) const
838 {
839 if ( U_FAILURE(status) ) {
840 return appendTo;
841 }
842 Calendar* workCal = &cal;
843 Calendar* calClone = NULL;
844 if (&cal != fCalendar && uprv_strcmp(cal.getType(), fCalendar->getType()) != 0) {
845 // Different calendar type
846 // We use the time and time zone from the input calendar, but
847 // do not use the input calendar for field calculation.
848 calClone = fCalendar->clone();
849 if (calClone != NULL) {
850 UDate t = cal.getTime(status);
851 calClone->setTime(t, status);
852 calClone->setTimeZone(cal.getTimeZone());
853 workCal = calClone;
854 } else {
855 status = U_MEMORY_ALLOCATION_ERROR;
856 return appendTo;
857 }
858 }
859
860 UBool inQuote = FALSE;
861 UChar prevCh = 0;
862 int32_t count = 0;
863 int32_t fieldNum = 0;
864
865 // loop through the pattern string character by character
866 for (int32_t i = 0; i < fPattern.length() && U_SUCCESS(status); ++i) {
867 UChar ch = fPattern[i];
868
869 // Use subFormat() to format a repeated pattern character
870 // when a different pattern or non-pattern character is seen
871 if (ch != prevCh && count > 0) {
872 subFormat(appendTo, prevCh, count, fCapitalizationContext, fieldNum++, handler, *workCal, status);
873 count = 0;
874 }
875 if (ch == QUOTE) {
876 // Consecutive single quotes are a single quote literal,
877 // either outside of quotes or between quotes
878 if ((i+1) < fPattern.length() && fPattern[i+1] == QUOTE) {
879 appendTo += (UChar)QUOTE;
880 ++i;
881 } else {
882 inQuote = ! inQuote;
883 }
884 }
885 else if ( ! inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
886 || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
887 // ch is a date-time pattern character to be interpreted
888 // by subFormat(); count the number of times it is repeated
889 prevCh = ch;
890 ++count;
891 }
892 else {
893 // Append quoted characters and unquoted non-pattern characters
894 appendTo += ch;
895 }
896 }
897
898 // Format the last item in the pattern, if any
899 if (count > 0) {
900 subFormat(appendTo, prevCh, count, fCapitalizationContext, fieldNum++, handler, *workCal, status);
901 }
902
903 if (calClone != NULL) {
904 delete calClone;
905 }
906
907 return appendTo;
908 }
909
910 //----------------------------------------------------------------------
911
912 /* Map calendar field into calendar field level.
913 * the larger the level, the smaller the field unit.
914 * For example, UCAL_ERA level is 0, UCAL_YEAR level is 10,
915 * UCAL_MONTH level is 20.
916 * NOTE: if new fields adds in, the table needs to update.
917 */
918 const int32_t
919 SimpleDateFormat::fgCalendarFieldToLevel[] =
920 {
921 /*GyM*/ 0, 10, 20,
922 /*wW*/ 20, 30,
923 /*dDEF*/ 30, 20, 30, 30,
924 /*ahHm*/ 40, 50, 50, 60,
925 /*sS..*/ 70, 80,
926 /*z?Y*/ 0, 0, 10,
927 /*eug*/ 30, 10, 0,
928 /*A*/ 40
929 };
930
931
932 /* Map calendar field LETTER into calendar field level.
933 * the larger the level, the smaller the field unit.
934 * NOTE: if new fields adds in, the table needs to update.
935 */
936 const int32_t
937 SimpleDateFormat::fgPatternCharToLevel[] = {
938 // A B C D E F G H I J K L M N O
939 -1, 40, -1, -1, 20, 30, 30, 0, 50, -1, -1, 50, 20, 20, -1, -1,
940 // P Q R S T U V W X Y Z
941 -1, 20, -1, 80, -1, 10, 0, 30, -1, 10, 0, -1, -1, -1, -1, -1,
942 // a b c d e f g h i j k l m n o
943 -1, 40, -1, 30, 30, 30, -1, 0, 50, -1, -1, 50, -1, 60, -1, -1,
944 // p q r s t u v w x y z
945 -1, 20, -1, 70, -1, 10, 0, 20, -1, 10, 0, -1, -1, -1, -1, -1
946 };
947
948
949 // Map index into pattern character string to Calendar field number.
950 const UCalendarDateFields
951 SimpleDateFormat::fgPatternIndexToCalendarField[] =
952 {
953 /*GyM*/ UCAL_ERA, UCAL_YEAR, UCAL_MONTH,
954 /*dkH*/ UCAL_DATE, UCAL_HOUR_OF_DAY, UCAL_HOUR_OF_DAY,
955 /*msS*/ UCAL_MINUTE, UCAL_SECOND, UCAL_MILLISECOND,
956 /*EDF*/ UCAL_DAY_OF_WEEK, UCAL_DAY_OF_YEAR, UCAL_DAY_OF_WEEK_IN_MONTH,
957 /*wWa*/ UCAL_WEEK_OF_YEAR, UCAL_WEEK_OF_MONTH, UCAL_AM_PM,
958 /*hKz*/ UCAL_HOUR, UCAL_HOUR, UCAL_ZONE_OFFSET,
959 /*Yeu*/ UCAL_YEAR_WOY, UCAL_DOW_LOCAL, UCAL_EXTENDED_YEAR,
960 /*gAZ*/ UCAL_JULIAN_DAY, UCAL_MILLISECONDS_IN_DAY, UCAL_ZONE_OFFSET,
961 /*v*/ UCAL_ZONE_OFFSET,
962 /*c*/ UCAL_DOW_LOCAL,
963 /*L*/ UCAL_MONTH,
964 /*Q*/ UCAL_MONTH,
965 /*q*/ UCAL_MONTH,
966 /*V*/ UCAL_ZONE_OFFSET,
967 /*U*/ UCAL_YEAR,
968 };
969
970 // Map index into pattern character string to DateFormat field number
971 const UDateFormatField
972 SimpleDateFormat::fgPatternIndexToDateFormatField[] = {
973 /*GyM*/ UDAT_ERA_FIELD, UDAT_YEAR_FIELD, UDAT_MONTH_FIELD,
974 /*dkH*/ UDAT_DATE_FIELD, UDAT_HOUR_OF_DAY1_FIELD, UDAT_HOUR_OF_DAY0_FIELD,
975 /*msS*/ UDAT_MINUTE_FIELD, UDAT_SECOND_FIELD, UDAT_FRACTIONAL_SECOND_FIELD,
976 /*EDF*/ UDAT_DAY_OF_WEEK_FIELD, UDAT_DAY_OF_YEAR_FIELD, UDAT_DAY_OF_WEEK_IN_MONTH_FIELD,
977 /*wWa*/ UDAT_WEEK_OF_YEAR_FIELD, UDAT_WEEK_OF_MONTH_FIELD, UDAT_AM_PM_FIELD,
978 /*hKz*/ UDAT_HOUR1_FIELD, UDAT_HOUR0_FIELD, UDAT_TIMEZONE_FIELD,
979 /*Yeu*/ UDAT_YEAR_WOY_FIELD, UDAT_DOW_LOCAL_FIELD, UDAT_EXTENDED_YEAR_FIELD,
980 /*gAZ*/ UDAT_JULIAN_DAY_FIELD, UDAT_MILLISECONDS_IN_DAY_FIELD, UDAT_TIMEZONE_RFC_FIELD,
981 /*v*/ UDAT_TIMEZONE_GENERIC_FIELD,
982 /*c*/ UDAT_STANDALONE_DAY_FIELD,
983 /*L*/ UDAT_STANDALONE_MONTH_FIELD,
984 /*Q*/ UDAT_QUARTER_FIELD,
985 /*q*/ UDAT_STANDALONE_QUARTER_FIELD,
986 /*V*/ UDAT_TIMEZONE_SPECIAL_FIELD,
987 /*U*/ UDAT_YEAR_NAME_FIELD,
988 };
989
990 //----------------------------------------------------------------------
991
992 /**
993 * Append symbols[value] to dst. Make sure the array index is not out
994 * of bounds.
995 */
996 static inline void
_appendSymbol(UnicodeString & dst,int32_t value,const UnicodeString * symbols,int32_t symbolsCount)997 _appendSymbol(UnicodeString& dst,
998 int32_t value,
999 const UnicodeString* symbols,
1000 int32_t symbolsCount) {
1001 U_ASSERT(0 <= value && value < symbolsCount);
1002 if (0 <= value && value < symbolsCount) {
1003 dst += symbols[value];
1004 }
1005 }
1006
1007 static inline void
_appendSymbolWithMonthPattern(UnicodeString & dst,int32_t value,const UnicodeString * symbols,int32_t symbolsCount,const UnicodeString * monthPattern,UErrorCode & status)1008 _appendSymbolWithMonthPattern(UnicodeString& dst, int32_t value, const UnicodeString* symbols, int32_t symbolsCount,
1009 const UnicodeString* monthPattern, UErrorCode& status) {
1010 U_ASSERT(0 <= value && value < symbolsCount);
1011 if (0 <= value && value < symbolsCount) {
1012 if (monthPattern == NULL) {
1013 dst += symbols[value];
1014 } else {
1015 Formattable monthName((const UnicodeString&)(symbols[value]));
1016 MessageFormat::format(*monthPattern, &monthName, 1, dst, status);
1017 }
1018 }
1019 }
1020
1021 //----------------------------------------------------------------------
1022 void
initNumberFormatters(const Locale & locale,UErrorCode & status)1023 SimpleDateFormat::initNumberFormatters(const Locale &locale,UErrorCode &status) {
1024 if (U_FAILURE(status)) {
1025 return;
1026 }
1027 if ( fDateOverride.isBogus() && fTimeOverride.isBogus() ) {
1028 return;
1029 }
1030 umtx_lock(&LOCK);
1031 if (fNumberFormatters == NULL) {
1032 fNumberFormatters = (NumberFormat**)uprv_malloc(UDAT_FIELD_COUNT * sizeof(NumberFormat*));
1033 if (fNumberFormatters) {
1034 for (int32_t i = 0; i < UDAT_FIELD_COUNT; i++) {
1035 fNumberFormatters[i] = fNumberFormat;
1036 }
1037 } else {
1038 status = U_MEMORY_ALLOCATION_ERROR;
1039 }
1040 }
1041 umtx_unlock(&LOCK);
1042
1043 processOverrideString(locale,fDateOverride,kOvrStrDate,status);
1044 processOverrideString(locale,fTimeOverride,kOvrStrTime,status);
1045
1046 }
1047
1048 void
processOverrideString(const Locale & locale,const UnicodeString & str,int8_t type,UErrorCode & status)1049 SimpleDateFormat::processOverrideString(const Locale &locale, const UnicodeString &str, int8_t type, UErrorCode &status) {
1050 if (str.isBogus()) {
1051 return;
1052 }
1053 int32_t start = 0;
1054 int32_t len;
1055 UnicodeString nsName;
1056 UnicodeString ovrField;
1057 UBool moreToProcess = TRUE;
1058
1059 while (moreToProcess) {
1060 int32_t delimiterPosition = str.indexOf((UChar)ULOC_KEYWORD_ITEM_SEPARATOR_UNICODE,start);
1061 if (delimiterPosition == -1) {
1062 moreToProcess = FALSE;
1063 len = str.length() - start;
1064 } else {
1065 len = delimiterPosition - start;
1066 }
1067 UnicodeString currentString(str,start,len);
1068 int32_t equalSignPosition = currentString.indexOf((UChar)ULOC_KEYWORD_ASSIGN_UNICODE,0);
1069 if (equalSignPosition == -1) { // Simple override string such as "hebrew"
1070 nsName.setTo(currentString);
1071 ovrField.setToBogus();
1072 } else { // Field specific override string such as "y=hebrew"
1073 nsName.setTo(currentString,equalSignPosition+1);
1074 ovrField.setTo(currentString,0,1); // We just need the first character.
1075 }
1076
1077 int32_t nsNameHash = nsName.hashCode();
1078 // See if the numbering system is in the override list, if not, then add it.
1079 NSOverride *cur = fOverrideList;
1080 NumberFormat *nf = NULL;
1081 UBool found = FALSE;
1082 while ( cur && !found ) {
1083 if ( cur->hash == nsNameHash ) {
1084 nf = cur->nf;
1085 found = TRUE;
1086 }
1087 cur = cur->next;
1088 }
1089
1090 if (!found) {
1091 cur = (NSOverride *)uprv_malloc(sizeof(NSOverride));
1092 if (cur) {
1093 char kw[ULOC_KEYWORD_AND_VALUES_CAPACITY];
1094 uprv_strcpy(kw,"numbers=");
1095 nsName.extract(0,len,kw+8,ULOC_KEYWORD_AND_VALUES_CAPACITY-8,US_INV);
1096
1097 Locale ovrLoc(locale.getLanguage(),locale.getCountry(),locale.getVariant(),kw);
1098 nf = NumberFormat::createInstance(ovrLoc,status);
1099
1100 // no matter what the locale's default number format looked like, we want
1101 // to modify it so that it doesn't use thousands separators, doesn't always
1102 // show the decimal point, and recognizes integers only when parsing
1103
1104 if (U_SUCCESS(status)) {
1105 nf->setGroupingUsed(FALSE);
1106 DecimalFormat* decfmt = dynamic_cast<DecimalFormat*>(nf);
1107 if (decfmt != NULL) {
1108 decfmt->setDecimalSeparatorAlwaysShown(FALSE);
1109 }
1110 nf->setParseIntegerOnly(TRUE);
1111 nf->setMinimumFractionDigits(0); // To prevent "Jan 1.00, 1997.00"
1112
1113 cur->nf = nf;
1114 cur->hash = nsNameHash;
1115 cur->next = fOverrideList;
1116 fOverrideList = cur;
1117 }
1118 else {
1119 // clean up before returning
1120 if (cur != NULL) {
1121 uprv_free(cur);
1122 }
1123 return;
1124 }
1125
1126 } else {
1127 status = U_MEMORY_ALLOCATION_ERROR;
1128 return;
1129 }
1130 }
1131
1132 // Now that we have an appropriate number formatter, fill in the appropriate spaces in the
1133 // number formatters table.
1134
1135 if (ovrField.isBogus()) {
1136 switch (type) {
1137 case kOvrStrDate:
1138 case kOvrStrBoth: {
1139 for ( int8_t i=0 ; i<kDateFieldsCount; i++ ) {
1140 fNumberFormatters[kDateFields[i]] = nf;
1141 }
1142 if (type==kOvrStrDate) {
1143 break;
1144 }
1145 }
1146 case kOvrStrTime : {
1147 for ( int8_t i=0 ; i<kTimeFieldsCount; i++ ) {
1148 fNumberFormatters[kTimeFields[i]] = nf;
1149 }
1150 break;
1151 }
1152 }
1153 } else {
1154 // if the pattern character is unrecognized, signal an error and bail out
1155 UDateFormatField patternCharIndex =
1156 DateFormatSymbols::getPatternCharIndex(ovrField.charAt(0));
1157 if (patternCharIndex == UDAT_FIELD_COUNT) {
1158 status = U_INVALID_FORMAT_ERROR;
1159 return;
1160 }
1161
1162 // Set the number formatter in the table
1163 fNumberFormatters[patternCharIndex] = nf;
1164 }
1165
1166 start = delimiterPosition + 1;
1167 }
1168 }
1169
1170 //---------------------------------------------------------------------
1171 void
subFormat(UnicodeString & appendTo,UChar ch,int32_t count,UDisplayContext capitalizationContext,int32_t fieldNum,FieldPositionHandler & handler,Calendar & cal,UErrorCode & status) const1172 SimpleDateFormat::subFormat(UnicodeString &appendTo,
1173 UChar ch,
1174 int32_t count,
1175 UDisplayContext capitalizationContext,
1176 int32_t fieldNum,
1177 FieldPositionHandler& handler,
1178 Calendar& cal,
1179 UErrorCode& status) const
1180 {
1181 if (U_FAILURE(status)) {
1182 return;
1183 }
1184
1185 // this function gets called by format() to produce the appropriate substitution
1186 // text for an individual pattern symbol (e.g., "HH" or "yyyy")
1187
1188 UDateFormatField patternCharIndex = DateFormatSymbols::getPatternCharIndex(ch);
1189 const int32_t maxIntCount = 10;
1190 int32_t beginOffset = appendTo.length();
1191 NumberFormat *currentNumberFormat;
1192 DateFormatSymbols::ECapitalizationContextUsageType capContextUsageType = DateFormatSymbols::kCapContextUsageOther;
1193
1194 UBool isHebrewCalendar = (uprv_strcmp(cal.getType(),"hebrew") == 0);
1195 UBool isChineseCalendar = (uprv_strcmp(cal.getType(),"chinese") == 0);
1196
1197 // if the pattern character is unrecognized, signal an error and dump out
1198 if (patternCharIndex == UDAT_FIELD_COUNT)
1199 {
1200 if (ch != 0x6C) { // pattern char 'l' (SMALL LETTER L) just gets ignored
1201 status = U_INVALID_FORMAT_ERROR;
1202 }
1203 return;
1204 }
1205
1206 UCalendarDateFields field = fgPatternIndexToCalendarField[patternCharIndex];
1207 int32_t value = cal.get(field, status);
1208 if (U_FAILURE(status)) {
1209 return;
1210 }
1211
1212 currentNumberFormat = getNumberFormatByIndex(patternCharIndex);
1213 UnicodeString hebr("hebr", 4, US_INV);
1214
1215 switch (patternCharIndex) {
1216
1217 // for any "G" symbol, write out the appropriate era string
1218 // "GGGG" is wide era name, "GGGGG" is narrow era name, anything else is abbreviated name
1219 case UDAT_ERA_FIELD:
1220 if (isChineseCalendar) {
1221 zeroPaddingNumber(currentNumberFormat,appendTo, value, 1, 9); // as in ICU4J
1222 } else {
1223 if (count == 5) {
1224 _appendSymbol(appendTo, value, fSymbols->fNarrowEras, fSymbols->fNarrowErasCount);
1225 capContextUsageType = DateFormatSymbols::kCapContextUsageEraNarrow;
1226 } else if (count == 4) {
1227 _appendSymbol(appendTo, value, fSymbols->fEraNames, fSymbols->fEraNamesCount);
1228 capContextUsageType = DateFormatSymbols::kCapContextUsageEraWide;
1229 } else {
1230 _appendSymbol(appendTo, value, fSymbols->fEras, fSymbols->fErasCount);
1231 capContextUsageType = DateFormatSymbols::kCapContextUsageEraAbbrev;
1232 }
1233 }
1234 break;
1235
1236 case UDAT_YEAR_NAME_FIELD:
1237 if (fSymbols->fShortYearNames != NULL && value <= fSymbols->fShortYearNamesCount) {
1238 // the Calendar YEAR field runs 1 through 60 for cyclic years
1239 _appendSymbol(appendTo, value - 1, fSymbols->fShortYearNames, fSymbols->fShortYearNamesCount);
1240 break;
1241 }
1242 // else fall through to numeric year handling, do not break here
1243
1244 // OLD: for "yyyy", write out the whole year; for "yy", write out the last 2 digits
1245 // NEW: UTS#35:
1246 //Year y yy yyy yyyy yyyyy
1247 //AD 1 1 01 001 0001 00001
1248 //AD 12 12 12 012 0012 00012
1249 //AD 123 123 23 123 0123 00123
1250 //AD 1234 1234 34 1234 1234 01234
1251 //AD 12345 12345 45 12345 12345 12345
1252 case UDAT_YEAR_FIELD:
1253 case UDAT_YEAR_WOY_FIELD:
1254 if (fDateOverride.compare(hebr)==0 && value>HEBREW_CAL_CUR_MILLENIUM_START_YEAR && value<HEBREW_CAL_CUR_MILLENIUM_END_YEAR) {
1255 value-=HEBREW_CAL_CUR_MILLENIUM_START_YEAR;
1256 }
1257 if(count == 2)
1258 zeroPaddingNumber(currentNumberFormat, appendTo, value, 2, 2);
1259 else
1260 zeroPaddingNumber(currentNumberFormat, appendTo, value, count, maxIntCount);
1261 break;
1262
1263 // for "MMMM"/"LLLL", write out the whole month name, for "MMM"/"LLL", write out the month
1264 // abbreviation, for "M"/"L" or "MM"/"LL", write out the month as a number with the
1265 // appropriate number of digits
1266 // for "MMMMM"/"LLLLL", use the narrow form
1267 case UDAT_MONTH_FIELD:
1268 case UDAT_STANDALONE_MONTH_FIELD:
1269 if ( isHebrewCalendar ) {
1270 HebrewCalendar *hc = (HebrewCalendar*)&cal;
1271 if (hc->isLeapYear(hc->get(UCAL_YEAR,status)) && value == 6 && count >= 3 )
1272 value = 13; // Show alternate form for Adar II in leap years in Hebrew calendar.
1273 if (!hc->isLeapYear(hc->get(UCAL_YEAR,status)) && value >= 6 && count < 3 )
1274 value--; // Adjust the month number down 1 in Hebrew non-leap years, i.e. Adar is 6, not 7.
1275 }
1276 {
1277 int32_t isLeapMonth = (fSymbols->fLeapMonthPatterns != NULL && fSymbols->fLeapMonthPatternsCount >= DateFormatSymbols::kMonthPatternsCount)?
1278 cal.get(UCAL_IS_LEAP_MONTH, status): 0;
1279 // should consolidate the next section by using arrays of pointers & counts for the right symbols...
1280 if (count == 5) {
1281 if (patternCharIndex == UDAT_MONTH_FIELD) {
1282 _appendSymbolWithMonthPattern(appendTo, value, fSymbols->fNarrowMonths, fSymbols->fNarrowMonthsCount,
1283 (isLeapMonth!=0)? &(fSymbols->fLeapMonthPatterns[DateFormatSymbols::kLeapMonthPatternFormatNarrow]): NULL, status);
1284 } else {
1285 _appendSymbolWithMonthPattern(appendTo, value, fSymbols->fStandaloneNarrowMonths, fSymbols->fStandaloneNarrowMonthsCount,
1286 (isLeapMonth!=0)? &(fSymbols->fLeapMonthPatterns[DateFormatSymbols::kLeapMonthPatternStandaloneNarrow]): NULL, status);
1287 }
1288 capContextUsageType = DateFormatSymbols::kCapContextUsageMonthNarrow;
1289 } else if (count == 4) {
1290 if (patternCharIndex == UDAT_MONTH_FIELD) {
1291 _appendSymbolWithMonthPattern(appendTo, value, fSymbols->fMonths, fSymbols->fMonthsCount,
1292 (isLeapMonth!=0)? &(fSymbols->fLeapMonthPatterns[DateFormatSymbols::kLeapMonthPatternFormatWide]): NULL, status);
1293 capContextUsageType = DateFormatSymbols::kCapContextUsageMonthFormat;
1294 } else {
1295 _appendSymbolWithMonthPattern(appendTo, value, fSymbols->fStandaloneMonths, fSymbols->fStandaloneMonthsCount,
1296 (isLeapMonth!=0)? &(fSymbols->fLeapMonthPatterns[DateFormatSymbols::kLeapMonthPatternStandaloneWide]): NULL, status);
1297 capContextUsageType = DateFormatSymbols::kCapContextUsageMonthStandalone;
1298 }
1299 } else if (count == 3) {
1300 if (patternCharIndex == UDAT_MONTH_FIELD) {
1301 _appendSymbolWithMonthPattern(appendTo, value, fSymbols->fShortMonths, fSymbols->fShortMonthsCount,
1302 (isLeapMonth!=0)? &(fSymbols->fLeapMonthPatterns[DateFormatSymbols::kLeapMonthPatternFormatAbbrev]): NULL, status);
1303 capContextUsageType = DateFormatSymbols::kCapContextUsageMonthFormat;
1304 } else {
1305 _appendSymbolWithMonthPattern(appendTo, value, fSymbols->fStandaloneShortMonths, fSymbols->fStandaloneShortMonthsCount,
1306 (isLeapMonth!=0)? &(fSymbols->fLeapMonthPatterns[DateFormatSymbols::kLeapMonthPatternStandaloneAbbrev]): NULL, status);
1307 capContextUsageType = DateFormatSymbols::kCapContextUsageMonthStandalone;
1308 }
1309 } else {
1310 UnicodeString monthNumber;
1311 zeroPaddingNumber(currentNumberFormat,monthNumber, value + 1, count, maxIntCount);
1312 _appendSymbolWithMonthPattern(appendTo, 0, &monthNumber, 1,
1313 (isLeapMonth!=0)? &(fSymbols->fLeapMonthPatterns[DateFormatSymbols::kLeapMonthPatternNumeric]): NULL, status);
1314 }
1315 }
1316 break;
1317
1318 // for "k" and "kk", write out the hour, adjusting midnight to appear as "24"
1319 case UDAT_HOUR_OF_DAY1_FIELD:
1320 if (value == 0)
1321 zeroPaddingNumber(currentNumberFormat,appendTo, cal.getMaximum(UCAL_HOUR_OF_DAY) + 1, count, maxIntCount);
1322 else
1323 zeroPaddingNumber(currentNumberFormat,appendTo, value, count, maxIntCount);
1324 break;
1325
1326 case UDAT_FRACTIONAL_SECOND_FIELD:
1327 // Fractional seconds left-justify
1328 {
1329 currentNumberFormat->setMinimumIntegerDigits((count > 3) ? 3 : count);
1330 currentNumberFormat->setMaximumIntegerDigits(maxIntCount);
1331 if (count == 1) {
1332 value /= 100;
1333 } else if (count == 2) {
1334 value /= 10;
1335 }
1336 FieldPosition p(0);
1337 currentNumberFormat->format(value, appendTo, p);
1338 if (count > 3) {
1339 currentNumberFormat->setMinimumIntegerDigits(count - 3);
1340 currentNumberFormat->format((int32_t)0, appendTo, p);
1341 }
1342 }
1343 break;
1344
1345 // for "ee" or "e", use local numeric day-of-the-week
1346 // for "EEEEE" or "eeeee", write out the narrow day-of-the-week name
1347 // for "EEEE" or "eeee", write out the wide day-of-the-week name
1348 // for "EEE" or "EE" or "E" or "eee", write out the abbreviated day-of-the-week name
1349 case UDAT_DOW_LOCAL_FIELD:
1350 if ( count < 3 ) {
1351 zeroPaddingNumber(currentNumberFormat,appendTo, value, count, maxIntCount);
1352 break;
1353 }
1354 // fall through to EEEEE-EEE handling, but for that we don't want local day-of-week,
1355 // we want standard day-of-week, so first fix value to work for EEEEE-EEE.
1356 value = cal.get(UCAL_DAY_OF_WEEK, status);
1357 if (U_FAILURE(status)) {
1358 return;
1359 }
1360 // fall through, do not break here
1361 case UDAT_DAY_OF_WEEK_FIELD:
1362 if (count == 5) {
1363 _appendSymbol(appendTo, value, fSymbols->fNarrowWeekdays,
1364 fSymbols->fNarrowWeekdaysCount);
1365 capContextUsageType = DateFormatSymbols::kCapContextUsageDayNarrow;
1366 } else if (count == 4) {
1367 _appendSymbol(appendTo, value, fSymbols->fWeekdays,
1368 fSymbols->fWeekdaysCount);
1369 capContextUsageType = DateFormatSymbols::kCapContextUsageDayFormat;
1370 } else {
1371 _appendSymbol(appendTo, value, fSymbols->fShortWeekdays,
1372 fSymbols->fShortWeekdaysCount);
1373 capContextUsageType = DateFormatSymbols::kCapContextUsageDayFormat;
1374 }
1375 break;
1376
1377 // for "ccc", write out the abbreviated day-of-the-week name
1378 // for "cccc", write out the wide day-of-the-week name
1379 // for "ccccc", use the narrow day-of-the-week name
1380 case UDAT_STANDALONE_DAY_FIELD:
1381 if ( count < 3 ) {
1382 zeroPaddingNumber(currentNumberFormat,appendTo, value, 1, maxIntCount);
1383 break;
1384 }
1385 // fall through to alpha DOW handling, but for that we don't want local day-of-week,
1386 // we want standard day-of-week, so first fix value.
1387 value = cal.get(UCAL_DAY_OF_WEEK, status);
1388 if (U_FAILURE(status)) {
1389 return;
1390 }
1391 if (count == 5) {
1392 _appendSymbol(appendTo, value, fSymbols->fStandaloneNarrowWeekdays,
1393 fSymbols->fStandaloneNarrowWeekdaysCount);
1394 capContextUsageType = DateFormatSymbols::kCapContextUsageDayNarrow;
1395 } else if (count == 4) {
1396 _appendSymbol(appendTo, value, fSymbols->fStandaloneWeekdays,
1397 fSymbols->fStandaloneWeekdaysCount);
1398 capContextUsageType = DateFormatSymbols::kCapContextUsageDayStandalone;
1399 } else { // count == 3
1400 _appendSymbol(appendTo, value, fSymbols->fStandaloneShortWeekdays,
1401 fSymbols->fStandaloneShortWeekdaysCount);
1402 capContextUsageType = DateFormatSymbols::kCapContextUsageDayStandalone;
1403 }
1404 break;
1405
1406 // for and "a" symbol, write out the whole AM/PM string
1407 case UDAT_AM_PM_FIELD:
1408 _appendSymbol(appendTo, value, fSymbols->fAmPms,
1409 fSymbols->fAmPmsCount);
1410 break;
1411
1412 // for "h" and "hh", write out the hour, adjusting noon and midnight to show up
1413 // as "12"
1414 case UDAT_HOUR1_FIELD:
1415 if (value == 0)
1416 zeroPaddingNumber(currentNumberFormat,appendTo, cal.getLeastMaximum(UCAL_HOUR) + 1, count, maxIntCount);
1417 else
1418 zeroPaddingNumber(currentNumberFormat,appendTo, value, count, maxIntCount);
1419 break;
1420
1421 // for the "z" symbols, we have to check our time zone data first. If we have a
1422 // localized name for the time zone, then "zzzz" / "zzz" indicate whether
1423 // daylight time is in effect (long/short) and "zz" / "z" do not (long/short).
1424 // If we don't have a localized time zone name,
1425 // then the time zone shows up as "GMT+hh:mm" or "GMT-hh:mm" (where "hh:mm" is the
1426 // offset from GMT) regardless of how many z's were in the pattern symbol
1427 case UDAT_TIMEZONE_FIELD:
1428 case UDAT_TIMEZONE_GENERIC_FIELD:
1429 case UDAT_TIMEZONE_SPECIAL_FIELD:
1430 case UDAT_TIMEZONE_RFC_FIELD: // 'Z' - TIMEZONE_RFC
1431 {
1432 UnicodeString zoneString;
1433 const TimeZone& tz = cal.getTimeZone();
1434 UDate date = cal.getTime(status);
1435 if (U_SUCCESS(status)) {
1436 if (patternCharIndex == UDAT_TIMEZONE_RFC_FIELD) {
1437 if (count < 4) {
1438 // "Z"
1439 tzFormat()->format(UTZFMT_STYLE_RFC822, tz, date, zoneString);
1440 } else if (count == 5) {
1441 // "ZZZZZ"
1442 tzFormat()->format(UTZFMT_STYLE_ISO8601, tz, date, zoneString);
1443 } else {
1444 // "ZZ", "ZZZ", "ZZZZ"
1445 tzFormat()->format(UTZFMT_STYLE_LOCALIZED_GMT, tz, date, zoneString);
1446 }
1447 } else if (patternCharIndex == UDAT_TIMEZONE_FIELD) {
1448 if (count < 4) {
1449 // "z", "zz", "zzz"
1450 tzFormat()->format(UTZFMT_STYLE_SPECIFIC_SHORT, tz, date, zoneString);
1451 capContextUsageType = DateFormatSymbols::kCapContextUsageMetazoneShort;
1452 } else {
1453 // "zzzz"
1454 tzFormat()->format(UTZFMT_STYLE_SPECIFIC_LONG, tz, date, zoneString);
1455 capContextUsageType = DateFormatSymbols::kCapContextUsageMetazoneLong;
1456 }
1457 } else if (patternCharIndex == UDAT_TIMEZONE_GENERIC_FIELD) {
1458 if (count == 1) {
1459 // "v"
1460 tzFormat()->format(UTZFMT_STYLE_GENERIC_SHORT, tz, date, zoneString);
1461 capContextUsageType = DateFormatSymbols::kCapContextUsageMetazoneShort;
1462 } else if (count == 4) {
1463 // "vvvv"
1464 tzFormat()->format(UTZFMT_STYLE_GENERIC_LONG, tz, date, zoneString);
1465 capContextUsageType = DateFormatSymbols::kCapContextUsageMetazoneLong;
1466 }
1467 } else { // patternCharIndex == UDAT_TIMEZONE_SPECIAL_FIELD
1468 if (count == 1) {
1469 // "V"
1470 tzFormat()->format(UTZFMT_STYLE_SPECIFIC_SHORT, tz, date, zoneString);
1471 capContextUsageType = DateFormatSymbols::kCapContextUsageMetazoneShort;
1472 } else if (count == 4) {
1473 // "VVVV"
1474 tzFormat()->format(UTZFMT_STYLE_GENERIC_LOCATION, tz, date, zoneString);
1475 capContextUsageType = DateFormatSymbols::kCapContextUsageZoneLong;
1476 }
1477 }
1478 }
1479 appendTo += zoneString;
1480 }
1481 break;
1482
1483 case UDAT_QUARTER_FIELD:
1484 if (count >= 4)
1485 _appendSymbol(appendTo, value/3, fSymbols->fQuarters,
1486 fSymbols->fQuartersCount);
1487 else if (count == 3)
1488 _appendSymbol(appendTo, value/3, fSymbols->fShortQuarters,
1489 fSymbols->fShortQuartersCount);
1490 else
1491 zeroPaddingNumber(currentNumberFormat,appendTo, (value/3) + 1, count, maxIntCount);
1492 break;
1493
1494 case UDAT_STANDALONE_QUARTER_FIELD:
1495 if (count >= 4)
1496 _appendSymbol(appendTo, value/3, fSymbols->fStandaloneQuarters,
1497 fSymbols->fStandaloneQuartersCount);
1498 else if (count == 3)
1499 _appendSymbol(appendTo, value/3, fSymbols->fStandaloneShortQuarters,
1500 fSymbols->fStandaloneShortQuartersCount);
1501 else
1502 zeroPaddingNumber(currentNumberFormat,appendTo, (value/3) + 1, count, maxIntCount);
1503 break;
1504
1505
1506 // all of the other pattern symbols can be formatted as simple numbers with
1507 // appropriate zero padding
1508 default:
1509 zeroPaddingNumber(currentNumberFormat,appendTo, value, count, maxIntCount);
1510 break;
1511 }
1512 #if !UCONFIG_NO_BREAK_ITERATION
1513 if (fieldNum == 0) {
1514 // first field, check to see whether we need to titlecase it
1515 UBool titlecase = FALSE;
1516 switch (capitalizationContext) {
1517 case UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE:
1518 titlecase = TRUE;
1519 break;
1520 case UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU:
1521 titlecase = fSymbols->fCapitalization[capContextUsageType][0];
1522 break;
1523 case UDISPCTX_CAPITALIZATION_FOR_STANDALONE:
1524 titlecase = fSymbols->fCapitalization[capContextUsageType][1];
1525 break;
1526 default:
1527 // titlecase = FALSE;
1528 break;
1529 }
1530 if (titlecase) {
1531 UnicodeString firstField(appendTo, beginOffset);
1532 firstField.toTitle(NULL, fLocale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
1533 appendTo.replaceBetween(beginOffset, appendTo.length(), firstField);
1534 }
1535 }
1536 #endif
1537
1538 handler.addAttribute(fgPatternIndexToDateFormatField[patternCharIndex], beginOffset, appendTo.length());
1539 }
1540
1541 //----------------------------------------------------------------------
1542
1543 NumberFormat *
getNumberFormatByIndex(UDateFormatField index) const1544 SimpleDateFormat::getNumberFormatByIndex(UDateFormatField index) const {
1545 if (fNumberFormatters != NULL) {
1546 return fNumberFormatters[index];
1547 } else {
1548 return fNumberFormat;
1549 }
1550 }
1551
1552 //----------------------------------------------------------------------
1553 void
zeroPaddingNumber(NumberFormat * currentNumberFormat,UnicodeString & appendTo,int32_t value,int32_t minDigits,int32_t maxDigits) const1554 SimpleDateFormat::zeroPaddingNumber(NumberFormat *currentNumberFormat,UnicodeString &appendTo,
1555 int32_t value, int32_t minDigits, int32_t maxDigits) const
1556 {
1557 if (currentNumberFormat!=NULL) {
1558 FieldPosition pos(0);
1559
1560 currentNumberFormat->setMinimumIntegerDigits(minDigits);
1561 currentNumberFormat->setMaximumIntegerDigits(maxDigits);
1562 currentNumberFormat->format(value, appendTo, pos); // 3rd arg is there to speed up processing
1563 }
1564 }
1565
1566 //----------------------------------------------------------------------
1567
1568 /**
1569 * Return true if the given format character, occuring count
1570 * times, represents a numeric field.
1571 */
isNumeric(UChar formatChar,int32_t count)1572 UBool SimpleDateFormat::isNumeric(UChar formatChar, int32_t count) {
1573 return DateFormatSymbols::isNumericPatternChar(formatChar, count);
1574 }
1575
1576 UBool
isAtNumericField(const UnicodeString & pattern,int32_t patternOffset)1577 SimpleDateFormat::isAtNumericField(const UnicodeString &pattern, int32_t patternOffset) {
1578 if (patternOffset >= pattern.length()) {
1579 // not at any field
1580 return FALSE;
1581 }
1582 UChar ch = pattern.charAt(patternOffset);
1583 UDateFormatField f = DateFormatSymbols::getPatternCharIndex(ch);
1584 if (f == UDAT_FIELD_COUNT) {
1585 // not at any field
1586 return FALSE;
1587 }
1588 int32_t i = patternOffset;
1589 while (pattern.charAt(++i) == ch) {}
1590 return DateFormatSymbols::isNumericField(f, i - patternOffset);
1591 }
1592
1593 UBool
isAfterNonNumericField(const UnicodeString & pattern,int32_t patternOffset)1594 SimpleDateFormat::isAfterNonNumericField(const UnicodeString &pattern, int32_t patternOffset) {
1595 if (patternOffset <= 0) {
1596 // not after any field
1597 return FALSE;
1598 }
1599 UChar ch = pattern.charAt(--patternOffset);
1600 UDateFormatField f = DateFormatSymbols::getPatternCharIndex(ch);
1601 if (f == UDAT_FIELD_COUNT) {
1602 // not after any field
1603 return FALSE;
1604 }
1605 int32_t i = patternOffset;
1606 while (pattern.charAt(--i) == ch) {}
1607 return !DateFormatSymbols::isNumericField(f, patternOffset - i);
1608 }
1609
1610 void
parse(const UnicodeString & text,Calendar & cal,ParsePosition & parsePos) const1611 SimpleDateFormat::parse(const UnicodeString& text, Calendar& cal, ParsePosition& parsePos) const
1612 {
1613 UErrorCode status = U_ZERO_ERROR;
1614 int32_t pos = parsePos.getIndex();
1615 int32_t start = pos;
1616
1617 UBool ambiguousYear[] = { FALSE };
1618 int32_t saveHebrewMonth = -1;
1619 int32_t count = 0;
1620
1621 UBool lenient = isLenient();
1622
1623 // hack, reset tztype, cast away const
1624 ((SimpleDateFormat*)this)->tztype = UTZFMT_TIME_TYPE_UNKNOWN;
1625
1626 // For parsing abutting numeric fields. 'abutPat' is the
1627 // offset into 'pattern' of the first of 2 or more abutting
1628 // numeric fields. 'abutStart' is the offset into 'text'
1629 // where parsing the fields begins. 'abutPass' starts off as 0
1630 // and increments each time we try to parse the fields.
1631 int32_t abutPat = -1; // If >=0, we are in a run of abutting numeric fields
1632 int32_t abutStart = 0;
1633 int32_t abutPass = 0;
1634 UBool inQuote = FALSE;
1635
1636 MessageFormat * numericLeapMonthFormatter = NULL;
1637
1638 Calendar* calClone = NULL;
1639 Calendar *workCal = &cal;
1640 if (&cal != fCalendar && uprv_strcmp(cal.getType(), fCalendar->getType()) != 0) {
1641 // Different calendar type
1642 // We use the time/zone from the input calendar, but
1643 // do not use the input calendar for field calculation.
1644 calClone = fCalendar->clone();
1645 if (calClone != NULL) {
1646 calClone->setTime(cal.getTime(status),status);
1647 if (U_FAILURE(status)) {
1648 goto ExitParse;
1649 }
1650 calClone->setTimeZone(cal.getTimeZone());
1651 workCal = calClone;
1652 } else {
1653 status = U_MEMORY_ALLOCATION_ERROR;
1654 goto ExitParse;
1655 }
1656 }
1657
1658 if (fSymbols->fLeapMonthPatterns != NULL && fSymbols->fLeapMonthPatternsCount >= DateFormatSymbols::kMonthPatternsCount) {
1659 numericLeapMonthFormatter = new MessageFormat(fSymbols->fLeapMonthPatterns[DateFormatSymbols::kLeapMonthPatternNumeric], fLocale, status);
1660 if (numericLeapMonthFormatter == NULL) {
1661 status = U_MEMORY_ALLOCATION_ERROR;
1662 goto ExitParse;
1663 } else if (U_FAILURE(status)) {
1664 goto ExitParse; // this will delete numericLeapMonthFormatter
1665 }
1666 }
1667
1668 for (int32_t i=0; i<fPattern.length(); ++i) {
1669 UChar ch = fPattern.charAt(i);
1670
1671 // Handle alphabetic field characters.
1672 if (!inQuote && ((ch >= 0x41 && ch <= 0x5A) || (ch >= 0x61 && ch <= 0x7A))) { // [A-Za-z]
1673 int32_t fieldPat = i;
1674
1675 // Count the length of this field specifier
1676 count = 1;
1677 while ((i+1)<fPattern.length() &&
1678 fPattern.charAt(i+1) == ch) {
1679 ++count;
1680 ++i;
1681 }
1682
1683 if (isNumeric(ch, count)) {
1684 if (abutPat < 0) {
1685 // Determine if there is an abutting numeric field.
1686 // Record the start of a set of abutting numeric fields.
1687 if (isAtNumericField(fPattern, i + 1)) {
1688 abutPat = fieldPat;
1689 abutStart = pos;
1690 abutPass = 0;
1691 }
1692 }
1693 } else {
1694 abutPat = -1; // End of any abutting fields
1695 }
1696
1697 // Handle fields within a run of abutting numeric fields. Take
1698 // the pattern "HHmmss" as an example. We will try to parse
1699 // 2/2/2 characters of the input text, then if that fails,
1700 // 1/2/2. We only adjust the width of the leftmost field; the
1701 // others remain fixed. This allows "123456" => 12:34:56, but
1702 // "12345" => 1:23:45. Likewise, for the pattern "yyyyMMdd" we
1703 // try 4/2/2, 3/2/2, 2/2/2, and finally 1/2/2.
1704 if (abutPat >= 0) {
1705 // If we are at the start of a run of abutting fields, then
1706 // shorten this field in each pass. If we can't shorten
1707 // this field any more, then the parse of this set of
1708 // abutting numeric fields has failed.
1709 if (fieldPat == abutPat) {
1710 count -= abutPass++;
1711 if (count == 0) {
1712 status = U_PARSE_ERROR;
1713 goto ExitParse;
1714 }
1715 }
1716
1717 pos = subParse(text, pos, ch, count,
1718 TRUE, FALSE, ambiguousYear, saveHebrewMonth, *workCal, i, numericLeapMonthFormatter);
1719
1720 // If the parse fails anywhere in the run, back up to the
1721 // start of the run and retry.
1722 if (pos < 0) {
1723 i = abutPat - 1;
1724 pos = abutStart;
1725 continue;
1726 }
1727 }
1728
1729 // Handle non-numeric fields and non-abutting numeric
1730 // fields.
1731 else if (ch != 0x6C) { // pattern char 'l' (SMALL LETTER L) just gets ignored
1732 int32_t s = subParse(text, pos, ch, count,
1733 FALSE, TRUE, ambiguousYear, saveHebrewMonth, *workCal, i, numericLeapMonthFormatter);
1734
1735 if (s == -pos-1) {
1736 // era not present, in special cases allow this to continue
1737 // from the position where the era was expected
1738 s = pos;
1739
1740 if (i+1 < fPattern.length()) {
1741 // move to next pattern character
1742 UChar ch = fPattern.charAt(i+1);
1743
1744 // check for whitespace
1745 if (PatternProps::isWhiteSpace(ch)) {
1746 i++;
1747 // Advance over run in pattern
1748 while ((i+1)<fPattern.length() &&
1749 PatternProps::isWhiteSpace(fPattern.charAt(i+1))) {
1750 ++i;
1751 }
1752 }
1753 }
1754 }
1755 else if (s <= 0) {
1756 status = U_PARSE_ERROR;
1757 goto ExitParse;
1758 }
1759 pos = s;
1760 }
1761 }
1762
1763 // Handle literal pattern characters. These are any
1764 // quoted characters and non-alphabetic unquoted
1765 // characters.
1766 else {
1767
1768 abutPat = -1; // End of any abutting fields
1769
1770 if (! matchLiterals(fPattern, i, text, pos, lenient)) {
1771 status = U_PARSE_ERROR;
1772 goto ExitParse;
1773 }
1774 }
1775 }
1776
1777 // Special hack for trailing "." after non-numeric field.
1778 if (text.charAt(pos) == 0x2e && lenient) {
1779 // only do if the last field is not numeric
1780 if (isAfterNonNumericField(fPattern, fPattern.length())) {
1781 pos++; // skip the extra "."
1782 }
1783 }
1784
1785 // At this point the fields of Calendar have been set. Calendar
1786 // will fill in default values for missing fields when the time
1787 // is computed.
1788
1789 parsePos.setIndex(pos);
1790
1791 // This part is a problem: When we call parsedDate.after, we compute the time.
1792 // Take the date April 3 2004 at 2:30 am. When this is first set up, the year
1793 // will be wrong if we're parsing a 2-digit year pattern. It will be 1904.
1794 // April 3 1904 is a Sunday (unlike 2004) so it is the DST onset day. 2:30 am
1795 // is therefore an "impossible" time, since the time goes from 1:59 to 3:00 am
1796 // on that day. It is therefore parsed out to fields as 3:30 am. Then we
1797 // add 100 years, and get April 3 2004 at 3:30 am. Note that April 3 2004 is
1798 // a Saturday, so it can have a 2:30 am -- and it should. [LIU]
1799 /*
1800 UDate parsedDate = calendar.getTime();
1801 if( ambiguousYear[0] && !parsedDate.after(fDefaultCenturyStart) ) {
1802 calendar.add(Calendar.YEAR, 100);
1803 parsedDate = calendar.getTime();
1804 }
1805 */
1806 // Because of the above condition, save off the fields in case we need to readjust.
1807 // The procedure we use here is not particularly efficient, but there is no other
1808 // way to do this given the API restrictions present in Calendar. We minimize
1809 // inefficiency by only performing this computation when it might apply, that is,
1810 // when the two-digit year is equal to the start year, and thus might fall at the
1811 // front or the back of the default century. This only works because we adjust
1812 // the year correctly to start with in other cases -- see subParse().
1813 if (ambiguousYear[0] || tztype != UTZFMT_TIME_TYPE_UNKNOWN) // If this is true then the two-digit year == the default start year
1814 {
1815 // We need a copy of the fields, and we need to avoid triggering a call to
1816 // complete(), which will recalculate the fields. Since we can't access
1817 // the fields[] array in Calendar, we clone the entire object. This will
1818 // stop working if Calendar.clone() is ever rewritten to call complete().
1819 Calendar *copy;
1820 if (ambiguousYear[0]) {
1821 copy = cal.clone();
1822 // Check for failed cloning.
1823 if (copy == NULL) {
1824 status = U_MEMORY_ALLOCATION_ERROR;
1825 goto ExitParse;
1826 }
1827 UDate parsedDate = copy->getTime(status);
1828 // {sfb} check internalGetDefaultCenturyStart
1829 if (fHaveDefaultCentury && (parsedDate < fDefaultCenturyStart)) {
1830 // We can't use add here because that does a complete() first.
1831 cal.set(UCAL_YEAR, fDefaultCenturyStartYear + 100);
1832 }
1833 delete copy;
1834 }
1835
1836 if (tztype != UTZFMT_TIME_TYPE_UNKNOWN) {
1837 copy = cal.clone();
1838 // Check for failed cloning.
1839 if (copy == NULL) {
1840 status = U_MEMORY_ALLOCATION_ERROR;
1841 goto ExitParse;
1842 }
1843 const TimeZone & tz = cal.getTimeZone();
1844 BasicTimeZone *btz = NULL;
1845
1846 if (dynamic_cast<const OlsonTimeZone *>(&tz) != NULL
1847 || dynamic_cast<const SimpleTimeZone *>(&tz) != NULL
1848 || dynamic_cast<const RuleBasedTimeZone *>(&tz) != NULL
1849 || dynamic_cast<const VTimeZone *>(&tz) != NULL) {
1850 btz = (BasicTimeZone*)&tz;
1851 }
1852
1853 // Get local millis
1854 copy->set(UCAL_ZONE_OFFSET, 0);
1855 copy->set(UCAL_DST_OFFSET, 0);
1856 UDate localMillis = copy->getTime(status);
1857
1858 // Make sure parsed time zone type (Standard or Daylight)
1859 // matches the rule used by the parsed time zone.
1860 int32_t raw, dst;
1861 if (btz != NULL) {
1862 if (tztype == UTZFMT_TIME_TYPE_STANDARD) {
1863 btz->getOffsetFromLocal(localMillis,
1864 BasicTimeZone::kStandard, BasicTimeZone::kStandard, raw, dst, status);
1865 } else {
1866 btz->getOffsetFromLocal(localMillis,
1867 BasicTimeZone::kDaylight, BasicTimeZone::kDaylight, raw, dst, status);
1868 }
1869 } else {
1870 // No good way to resolve ambiguous time at transition,
1871 // but following code work in most case.
1872 tz.getOffset(localMillis, TRUE, raw, dst, status);
1873 }
1874
1875 // Now, compare the results with parsed type, either standard or daylight saving time
1876 int32_t resolvedSavings = dst;
1877 if (tztype == UTZFMT_TIME_TYPE_STANDARD) {
1878 if (dst != 0) {
1879 // Override DST_OFFSET = 0 in the result calendar
1880 resolvedSavings = 0;
1881 }
1882 } else { // tztype == TZTYPE_DST
1883 if (dst == 0) {
1884 if (btz != NULL) {
1885 UDate time = localMillis + raw;
1886 // We use the nearest daylight saving time rule.
1887 TimeZoneTransition beforeTrs, afterTrs;
1888 UDate beforeT = time, afterT = time;
1889 int32_t beforeSav = 0, afterSav = 0;
1890 UBool beforeTrsAvail, afterTrsAvail;
1891
1892 // Search for DST rule before or on the time
1893 while (TRUE) {
1894 beforeTrsAvail = btz->getPreviousTransition(beforeT, TRUE, beforeTrs);
1895 if (!beforeTrsAvail) {
1896 break;
1897 }
1898 beforeT = beforeTrs.getTime() - 1;
1899 beforeSav = beforeTrs.getFrom()->getDSTSavings();
1900 if (beforeSav != 0) {
1901 break;
1902 }
1903 }
1904
1905 // Search for DST rule after the time
1906 while (TRUE) {
1907 afterTrsAvail = btz->getNextTransition(afterT, FALSE, afterTrs);
1908 if (!afterTrsAvail) {
1909 break;
1910 }
1911 afterT = afterTrs.getTime();
1912 afterSav = afterTrs.getTo()->getDSTSavings();
1913 if (afterSav != 0) {
1914 break;
1915 }
1916 }
1917
1918 if (beforeTrsAvail && afterTrsAvail) {
1919 if (time - beforeT > afterT - time) {
1920 resolvedSavings = afterSav;
1921 } else {
1922 resolvedSavings = beforeSav;
1923 }
1924 } else if (beforeTrsAvail && beforeSav != 0) {
1925 resolvedSavings = beforeSav;
1926 } else if (afterTrsAvail && afterSav != 0) {
1927 resolvedSavings = afterSav;
1928 } else {
1929 resolvedSavings = btz->getDSTSavings();
1930 }
1931 } else {
1932 resolvedSavings = tz.getDSTSavings();
1933 }
1934 if (resolvedSavings == 0) {
1935 // final fallback
1936 resolvedSavings = U_MILLIS_PER_HOUR;
1937 }
1938 }
1939 }
1940 cal.set(UCAL_ZONE_OFFSET, raw);
1941 cal.set(UCAL_DST_OFFSET, resolvedSavings);
1942 delete copy;
1943 }
1944 }
1945 ExitParse:
1946 // Set the parsed result if local calendar is used
1947 // instead of the input calendar
1948 if (U_SUCCESS(status) && workCal != &cal) {
1949 cal.setTimeZone(workCal->getTimeZone());
1950 cal.setTime(workCal->getTime(status), status);
1951 }
1952
1953 if (numericLeapMonthFormatter != NULL) {
1954 delete numericLeapMonthFormatter;
1955 }
1956 if (calClone != NULL) {
1957 delete calClone;
1958 }
1959
1960 // If any Calendar calls failed, we pretend that we
1961 // couldn't parse the string, when in reality this isn't quite accurate--
1962 // we did parse it; the Calendar calls just failed.
1963 if (U_FAILURE(status)) {
1964 parsePos.setErrorIndex(pos);
1965 parsePos.setIndex(start);
1966 }
1967 }
1968
1969 UDate
parse(const UnicodeString & text,ParsePosition & pos) const1970 SimpleDateFormat::parse( const UnicodeString& text,
1971 ParsePosition& pos) const {
1972 // redefined here because the other parse() function hides this function's
1973 // cunterpart on DateFormat
1974 return DateFormat::parse(text, pos);
1975 }
1976
1977 UDate
parse(const UnicodeString & text,UErrorCode & status) const1978 SimpleDateFormat::parse(const UnicodeString& text, UErrorCode& status) const
1979 {
1980 // redefined here because the other parse() function hides this function's
1981 // counterpart on DateFormat
1982 return DateFormat::parse(text, status);
1983 }
1984 //----------------------------------------------------------------------
1985
1986 static UBool
1987 newBestMatchWithOptionalDot(const UnicodeString &lcaseText,
1988 const UnicodeString &data,
1989 UnicodeString &bestMatchName,
1990 int32_t &bestMatchLength);
1991
matchQuarterString(const UnicodeString & text,int32_t start,UCalendarDateFields field,const UnicodeString * data,int32_t dataCount,Calendar & cal) const1992 int32_t SimpleDateFormat::matchQuarterString(const UnicodeString& text,
1993 int32_t start,
1994 UCalendarDateFields field,
1995 const UnicodeString* data,
1996 int32_t dataCount,
1997 Calendar& cal) const
1998 {
1999 int32_t i = 0;
2000 int32_t count = dataCount;
2001
2002 // There may be multiple strings in the data[] array which begin with
2003 // the same prefix (e.g., Cerven and Cervenec (June and July) in Czech).
2004 // We keep track of the longest match, and return that. Note that this
2005 // unfortunately requires us to test all array elements.
2006 int32_t bestMatchLength = 0, bestMatch = -1;
2007 UnicodeString bestMatchName;
2008
2009 // {sfb} kludge to support case-insensitive comparison
2010 // {markus 2002oct11} do not just use caseCompareBetween because we do not know
2011 // the length of the match after case folding
2012 // {alan 20040607} don't case change the whole string, since the length
2013 // can change
2014 // TODO we need a case-insensitive startsWith function
2015 UnicodeString lcaseText;
2016 text.extract(start, INT32_MAX, lcaseText);
2017 lcaseText.foldCase();
2018
2019 for (; i < count; ++i)
2020 {
2021 // Always compare if we have no match yet; otherwise only compare
2022 // against potentially better matches (longer strings).
2023
2024 if (newBestMatchWithOptionalDot(lcaseText, data[i], bestMatchName, bestMatchLength)) {
2025 bestMatch = i;
2026 }
2027 }
2028 if (bestMatch >= 0)
2029 {
2030 cal.set(field, bestMatch * 3);
2031
2032 // Once we have a match, we have to determine the length of the
2033 // original source string. This will usually be == the length of
2034 // the case folded string, but it may differ (e.g. sharp s).
2035
2036 // Most of the time, the length will be the same as the length
2037 // of the string from the locale data. Sometimes it will be
2038 // different, in which case we will have to figure it out by
2039 // adding a character at a time, until we have a match. We do
2040 // this all in one loop, where we try 'len' first (at index
2041 // i==0).
2042 int32_t len = bestMatchName.length(); // 99+% of the time
2043 int32_t n = text.length() - start;
2044 for (i=0; i<=n; ++i) {
2045 int32_t j=i;
2046 if (i == 0) {
2047 j = len;
2048 } else if (i == len) {
2049 continue; // already tried this when i was 0
2050 }
2051 text.extract(start, j, lcaseText);
2052 lcaseText.foldCase();
2053 if (bestMatchName == lcaseText) {
2054 return start + j;
2055 }
2056 }
2057 }
2058
2059 return -start;
2060 }
2061
2062 //----------------------------------------------------------------------
matchLiterals(const UnicodeString & pattern,int32_t & patternOffset,const UnicodeString & text,int32_t & textOffset,UBool lenient)2063 UBool SimpleDateFormat::matchLiterals(const UnicodeString &pattern,
2064 int32_t &patternOffset,
2065 const UnicodeString &text,
2066 int32_t &textOffset,
2067 UBool lenient)
2068 {
2069 UBool inQuote = FALSE;
2070 UnicodeString literal;
2071 int32_t i = patternOffset;
2072
2073 // scan pattern looking for contiguous literal characters
2074 for ( ; i < pattern.length(); i += 1) {
2075 UChar ch = pattern.charAt(i);
2076
2077 if (!inQuote && ((ch >= 0x41 && ch <= 0x5A) || (ch >= 0x61 && ch <= 0x7A))) { // unquoted [A-Za-z]
2078 break;
2079 }
2080
2081 if (ch == QUOTE) {
2082 // Match a quote literal ('') inside OR outside of quotes
2083 if ((i + 1) < pattern.length() && pattern.charAt(i + 1) == QUOTE) {
2084 i += 1;
2085 } else {
2086 inQuote = !inQuote;
2087 continue;
2088 }
2089 }
2090
2091 literal += ch;
2092 }
2093
2094 // at this point, literal contains the literal text
2095 // and i is the index of the next non-literal pattern character.
2096 int32_t p;
2097 int32_t t = textOffset;
2098
2099 if (lenient) {
2100 // trim leading, trailing whitespace from
2101 // the literal text
2102 literal.trim();
2103
2104 // ignore any leading whitespace in the text
2105 while (t < text.length() && u_isWhitespace(text.charAt(t))) {
2106 t += 1;
2107 }
2108 }
2109
2110 for (p = 0; p < literal.length() && t < text.length();) {
2111 UBool needWhitespace = FALSE;
2112
2113 while (p < literal.length() && PatternProps::isWhiteSpace(literal.charAt(p))) {
2114 needWhitespace = TRUE;
2115 p += 1;
2116 }
2117
2118 if (needWhitespace) {
2119 int32_t tStart = t;
2120
2121 while (t < text.length()) {
2122 UChar tch = text.charAt(t);
2123
2124 if (!u_isUWhiteSpace(tch) && !PatternProps::isWhiteSpace(tch)) {
2125 break;
2126 }
2127
2128 t += 1;
2129 }
2130
2131 // TODO: should we require internal spaces
2132 // in lenient mode? (There won't be any
2133 // leading or trailing spaces)
2134 if (!lenient && t == tStart) {
2135 // didn't find matching whitespace:
2136 // an error in strict mode
2137 return FALSE;
2138 }
2139
2140 // In strict mode, this run of whitespace
2141 // may have been at the end.
2142 if (p >= literal.length()) {
2143 break;
2144 }
2145 }
2146
2147 if (t >= text.length() || literal.charAt(p) != text.charAt(t)) {
2148 // Ran out of text, or found a non-matching character:
2149 // OK in lenient mode, an error in strict mode.
2150 if (lenient) {
2151 if (t == textOffset && text.charAt(t) == 0x2e &&
2152 isAfterNonNumericField(pattern, patternOffset)) {
2153 // Lenient mode and the literal input text begins with a "." and
2154 // we are after a non-numeric field: We skip the "."
2155 ++t;
2156 continue; // Do not update p.
2157 }
2158 break;
2159 }
2160
2161 return FALSE;
2162 }
2163 ++p;
2164 ++t;
2165 }
2166
2167 // At this point if we're in strict mode we have a complete match.
2168 // If we're in lenient mode we may have a partial match, or no
2169 // match at all.
2170 if (p <= 0) {
2171 // no match. Pretend it matched a run of whitespace
2172 // and ignorables in the text.
2173 const UnicodeSet *ignorables = NULL;
2174 UDateFormatField patternCharIndex = DateFormatSymbols::getPatternCharIndex(pattern.charAt(i));
2175 if (patternCharIndex != UDAT_FIELD_COUNT) {
2176 ignorables = SimpleDateFormatStaticSets::getIgnorables(patternCharIndex);
2177 }
2178
2179 for (t = textOffset; t < text.length(); t += 1) {
2180 UChar ch = text.charAt(t);
2181
2182 if (ignorables == NULL || !ignorables->contains(ch)) {
2183 break;
2184 }
2185 }
2186 }
2187
2188 // if we get here, we've got a complete match.
2189 patternOffset = i - 1;
2190 textOffset = t;
2191
2192 return TRUE;
2193 }
2194
2195 //----------------------------------------------------------------------
2196
matchString(const UnicodeString & text,int32_t start,UCalendarDateFields field,const UnicodeString * data,int32_t dataCount,const UnicodeString * monthPattern,Calendar & cal) const2197 int32_t SimpleDateFormat::matchString(const UnicodeString& text,
2198 int32_t start,
2199 UCalendarDateFields field,
2200 const UnicodeString* data,
2201 int32_t dataCount,
2202 const UnicodeString* monthPattern,
2203 Calendar& cal) const
2204 {
2205 int32_t i = 0;
2206 int32_t count = dataCount;
2207
2208 if (field == UCAL_DAY_OF_WEEK) i = 1;
2209
2210 // There may be multiple strings in the data[] array which begin with
2211 // the same prefix (e.g., Cerven and Cervenec (June and July) in Czech).
2212 // We keep track of the longest match, and return that. Note that this
2213 // unfortunately requires us to test all array elements.
2214 int32_t bestMatchLength = 0, bestMatch = -1;
2215 UnicodeString bestMatchName;
2216 int32_t isLeapMonth = 0;
2217
2218 // {sfb} kludge to support case-insensitive comparison
2219 // {markus 2002oct11} do not just use caseCompareBetween because we do not know
2220 // the length of the match after case folding
2221 // {alan 20040607} don't case change the whole string, since the length
2222 // can change
2223 // TODO we need a case-insensitive startsWith function
2224 UnicodeString lcaseText;
2225 text.extract(start, INT32_MAX, lcaseText);
2226 lcaseText.foldCase();
2227
2228 for (; i < count; ++i)
2229 {
2230 // Always compare if we have no match yet; otherwise only compare
2231 // against potentially better matches (longer strings).
2232
2233 if (newBestMatchWithOptionalDot(lcaseText, data[i], bestMatchName, bestMatchLength)) {
2234 bestMatch = i;
2235 isLeapMonth = 0;
2236 }
2237
2238 if (monthPattern != NULL) {
2239 UErrorCode status = U_ZERO_ERROR;
2240 UnicodeString leapMonthName;
2241 Formattable monthName((const UnicodeString&)(data[i]));
2242 MessageFormat::format(*monthPattern, &monthName, 1, leapMonthName, status);
2243 if (U_SUCCESS(status)) {
2244 if (newBestMatchWithOptionalDot(lcaseText, leapMonthName, bestMatchName, bestMatchLength)) {
2245 bestMatch = i;
2246 isLeapMonth = 1;
2247 }
2248 }
2249 }
2250 }
2251 if (bestMatch >= 0)
2252 {
2253 // Adjustment for Hebrew Calendar month Adar II
2254 if (!strcmp(cal.getType(),"hebrew") && field==UCAL_MONTH && bestMatch==13) {
2255 cal.set(field,6);
2256 }
2257 else {
2258 if (field == UCAL_YEAR) {
2259 bestMatch++; // only get here for cyclic year names, which match 1-based years 1-60
2260 }
2261 cal.set(field, bestMatch);
2262 }
2263 if (monthPattern != NULL) {
2264 cal.set(UCAL_IS_LEAP_MONTH, isLeapMonth);
2265 }
2266
2267 // Once we have a match, we have to determine the length of the
2268 // original source string. This will usually be == the length of
2269 // the case folded string, but it may differ (e.g. sharp s).
2270
2271 // Most of the time, the length will be the same as the length
2272 // of the string from the locale data. Sometimes it will be
2273 // different, in which case we will have to figure it out by
2274 // adding a character at a time, until we have a match. We do
2275 // this all in one loop, where we try 'len' first (at index
2276 // i==0).
2277 int32_t len = bestMatchName.length(); // 99+% of the time
2278 int32_t n = text.length() - start;
2279 for (i=0; i<=n; ++i) {
2280 int32_t j=i;
2281 if (i == 0) {
2282 j = len;
2283 } else if (i == len) {
2284 continue; // already tried this when i was 0
2285 }
2286 text.extract(start, j, lcaseText);
2287 lcaseText.foldCase();
2288 if (bestMatchName == lcaseText) {
2289 return start + j;
2290 }
2291 }
2292 }
2293
2294 return -start;
2295 }
2296
2297 static UBool
newBestMatchWithOptionalDot(const UnicodeString & lcaseText,const UnicodeString & data,UnicodeString & bestMatchName,int32_t & bestMatchLength)2298 newBestMatchWithOptionalDot(const UnicodeString &lcaseText,
2299 const UnicodeString &data,
2300 UnicodeString &bestMatchName,
2301 int32_t &bestMatchLength) {
2302 UnicodeString lcase;
2303 lcase.fastCopyFrom(data).foldCase();
2304 int32_t length = lcase.length();
2305 if (length <= bestMatchLength) {
2306 // data cannot provide a better match.
2307 return FALSE;
2308 }
2309
2310 if (lcaseText.compareBetween(0, length, lcase, 0, length) == 0) {
2311 // normal match
2312 bestMatchName = lcase;
2313 bestMatchLength = length;
2314 return TRUE;
2315 }
2316 if (lcase.charAt(--length) == 0x2e) {
2317 if (lcaseText.compareBetween(0, length, lcase, 0, length) == 0) {
2318 // The input text matches the data except for data's trailing dot.
2319 bestMatchName = lcase;
2320 bestMatchName.truncate(length);
2321 bestMatchLength = length;
2322 return TRUE;
2323 }
2324 }
2325 return FALSE;
2326 }
2327
2328 //----------------------------------------------------------------------
2329
2330 void
set2DigitYearStart(UDate d,UErrorCode & status)2331 SimpleDateFormat::set2DigitYearStart(UDate d, UErrorCode& status)
2332 {
2333 parseAmbiguousDatesAsAfter(d, status);
2334 }
2335
2336 /**
2337 * Private member function that converts the parsed date strings into
2338 * timeFields. Returns -start (for ParsePosition) if failed.
2339 * @param text the time text to be parsed.
2340 * @param start where to start parsing.
2341 * @param ch the pattern character for the date field text to be parsed.
2342 * @param count the count of a pattern character.
2343 * @return the new start position if matching succeeded; a negative number
2344 * indicating matching failure, otherwise.
2345 */
subParse(const UnicodeString & text,int32_t & start,UChar ch,int32_t count,UBool obeyCount,UBool allowNegative,UBool ambiguousYear[],int32_t & saveHebrewMonth,Calendar & cal,int32_t patLoc,MessageFormat * numericLeapMonthFormatter) const2346 int32_t SimpleDateFormat::subParse(const UnicodeString& text, int32_t& start, UChar ch, int32_t count,
2347 UBool obeyCount, UBool allowNegative, UBool ambiguousYear[], int32_t& saveHebrewMonth, Calendar& cal,
2348 int32_t patLoc, MessageFormat * numericLeapMonthFormatter) const
2349 {
2350 Formattable number;
2351 int32_t value = 0;
2352 int32_t i;
2353 int32_t ps = 0;
2354 ParsePosition pos(0);
2355 UDateFormatField patternCharIndex = DateFormatSymbols::getPatternCharIndex(ch);
2356 NumberFormat *currentNumberFormat;
2357 UnicodeString temp;
2358 UBool lenient = isLenient();
2359 UBool gotNumber = FALSE;
2360
2361 #if defined (U_DEBUG_CAL)
2362 //fprintf(stderr, "%s:%d - [%c] st=%d \n", __FILE__, __LINE__, (char) ch, start);
2363 #endif
2364
2365 if (patternCharIndex == UDAT_FIELD_COUNT) {
2366 return -start;
2367 }
2368
2369 currentNumberFormat = getNumberFormatByIndex(patternCharIndex);
2370 UCalendarDateFields field = fgPatternIndexToCalendarField[patternCharIndex];
2371 UnicodeString hebr("hebr", 4, US_INV);
2372
2373 if (numericLeapMonthFormatter != NULL) {
2374 numericLeapMonthFormatter->setFormats((const Format **)¤tNumberFormat, 1);
2375 }
2376 UBool isChineseCalendar = (uprv_strcmp(cal.getType(),"chinese") == 0);
2377
2378 // If there are any spaces here, skip over them. If we hit the end
2379 // of the string, then fail.
2380 for (;;) {
2381 if (start >= text.length()) {
2382 return -start;
2383 }
2384 UChar32 c = text.char32At(start);
2385 if (!u_isUWhiteSpace(c) /*||*/ && !PatternProps::isWhiteSpace(c)) {
2386 break;
2387 }
2388 start += U16_LENGTH(c);
2389 }
2390 pos.setIndex(start);
2391
2392 // We handle a few special cases here where we need to parse
2393 // a number value. We handle further, more generic cases below. We need
2394 // to handle some of them here because some fields require extra processing on
2395 // the parsed value.
2396 if (patternCharIndex == UDAT_HOUR_OF_DAY1_FIELD || // k
2397 patternCharIndex == UDAT_HOUR_OF_DAY0_FIELD || // H
2398 patternCharIndex == UDAT_HOUR1_FIELD || // h
2399 patternCharIndex == UDAT_HOUR0_FIELD || // K
2400 (patternCharIndex == UDAT_DOW_LOCAL_FIELD && count <= 2) || // e
2401 (patternCharIndex == UDAT_STANDALONE_DAY_FIELD && count <= 2) || // c
2402 (patternCharIndex == UDAT_MONTH_FIELD && count <= 2) || // M
2403 (patternCharIndex == UDAT_STANDALONE_MONTH_FIELD && count <= 2) || // L
2404 (patternCharIndex == UDAT_QUARTER_FIELD && count <= 2) || // Q
2405 (patternCharIndex == UDAT_STANDALONE_QUARTER_FIELD && count <= 2) || // q
2406 patternCharIndex == UDAT_YEAR_FIELD || // y
2407 patternCharIndex == UDAT_YEAR_WOY_FIELD || // Y
2408 patternCharIndex == UDAT_YEAR_NAME_FIELD || // U (falls back to numeric)
2409 (patternCharIndex == UDAT_ERA_FIELD && isChineseCalendar) || // G
2410 patternCharIndex == UDAT_FRACTIONAL_SECOND_FIELD) // S
2411 {
2412 int32_t parseStart = pos.getIndex();
2413 // It would be good to unify this with the obeyCount logic below,
2414 // but that's going to be difficult.
2415 const UnicodeString* src;
2416
2417 UBool parsedNumericLeapMonth = FALSE;
2418 if (numericLeapMonthFormatter != NULL && (patternCharIndex == UDAT_MONTH_FIELD || patternCharIndex == UDAT_STANDALONE_MONTH_FIELD)) {
2419 int32_t argCount;
2420 Formattable * args = numericLeapMonthFormatter->parse(text, pos, argCount);
2421 if (args != NULL && argCount == 1 && pos.getIndex() > parseStart && args[0].isNumeric()) {
2422 parsedNumericLeapMonth = TRUE;
2423 number.setLong(args[0].getLong());
2424 cal.set(UCAL_IS_LEAP_MONTH, 1);
2425 delete[] args;
2426 } else {
2427 pos.setIndex(parseStart);
2428 cal.set(UCAL_IS_LEAP_MONTH, 0);
2429 }
2430 }
2431
2432 if (!parsedNumericLeapMonth) {
2433 if (obeyCount) {
2434 if ((start+count) > text.length()) {
2435 return -start;
2436 }
2437
2438 text.extractBetween(0, start + count, temp);
2439 src = &temp;
2440 } else {
2441 src = &text;
2442 }
2443
2444 parseInt(*src, number, pos, allowNegative,currentNumberFormat);
2445 }
2446
2447 int32_t txtLoc = pos.getIndex();
2448
2449 if (txtLoc > parseStart) {
2450 value = number.getLong();
2451 gotNumber = TRUE;
2452
2453 // suffix processing
2454 if (value < 0 ) {
2455 txtLoc = checkIntSuffix(text, txtLoc, patLoc+1, TRUE);
2456 if (txtLoc != pos.getIndex()) {
2457 value *= -1;
2458 }
2459 }
2460 else {
2461 txtLoc = checkIntSuffix(text, txtLoc, patLoc+1, FALSE);
2462 }
2463
2464 if (!lenient) {
2465 // Check the range of the value
2466 int32_t bias = gFieldRangeBias[patternCharIndex];
2467 if (bias >= 0 && (value > cal.getMaximum(field) + bias || value < cal.getMinimum(field) + bias)) {
2468 return -start;
2469 }
2470 }
2471
2472 pos.setIndex(txtLoc);
2473 }
2474 }
2475
2476 // Make sure that we got a number if
2477 // we want one, and didn't get one
2478 // if we don't want one.
2479 switch (patternCharIndex) {
2480 case UDAT_HOUR_OF_DAY1_FIELD:
2481 case UDAT_HOUR_OF_DAY0_FIELD:
2482 case UDAT_HOUR1_FIELD:
2483 case UDAT_HOUR0_FIELD:
2484 // special range check for hours:
2485 if (value < 0 || value > 24) {
2486 return -start;
2487 }
2488
2489 // fall through to gotNumber check
2490
2491 case UDAT_YEAR_FIELD:
2492 case UDAT_YEAR_WOY_FIELD:
2493 case UDAT_FRACTIONAL_SECOND_FIELD:
2494 // these must be a number
2495 if (! gotNumber) {
2496 return -start;
2497 }
2498
2499 break;
2500
2501 default:
2502 // we check the rest of the fields below.
2503 break;
2504 }
2505
2506 switch (patternCharIndex) {
2507 case UDAT_ERA_FIELD:
2508 if (isChineseCalendar) {
2509 if (!gotNumber) {
2510 return -start;
2511 }
2512 cal.set(UCAL_ERA, value);
2513 return pos.getIndex();
2514 }
2515 if (count == 5) {
2516 ps = matchString(text, start, UCAL_ERA, fSymbols->fNarrowEras, fSymbols->fNarrowErasCount, NULL, cal);
2517 } else if (count == 4) {
2518 ps = matchString(text, start, UCAL_ERA, fSymbols->fEraNames, fSymbols->fEraNamesCount, NULL, cal);
2519 } else {
2520 ps = matchString(text, start, UCAL_ERA, fSymbols->fEras, fSymbols->fErasCount, NULL, cal);
2521 }
2522
2523 // check return position, if it equals -start, then matchString error
2524 // special case the return code so we don't necessarily fail out until we
2525 // verify no year information also
2526 if (ps == -start)
2527 ps--;
2528
2529 return ps;
2530
2531 case UDAT_YEAR_FIELD:
2532 // If there are 3 or more YEAR pattern characters, this indicates
2533 // that the year value is to be treated literally, without any
2534 // two-digit year adjustments (e.g., from "01" to 2001). Otherwise
2535 // we made adjustments to place the 2-digit year in the proper
2536 // century, for parsed strings from "00" to "99". Any other string
2537 // is treated literally: "2250", "-1", "1", "002".
2538 if (fDateOverride.compare(hebr)==0 && value < 1000) {
2539 value += HEBREW_CAL_CUR_MILLENIUM_START_YEAR;
2540 } else if ((pos.getIndex() - start) == 2 && !isChineseCalendar
2541 && u_isdigit(text.charAt(start))
2542 && u_isdigit(text.charAt(start+1)))
2543 {
2544 // Assume for example that the defaultCenturyStart is 6/18/1903.
2545 // This means that two-digit years will be forced into the range
2546 // 6/18/1903 to 6/17/2003. As a result, years 00, 01, and 02
2547 // correspond to 2000, 2001, and 2002. Years 04, 05, etc. correspond
2548 // to 1904, 1905, etc. If the year is 03, then it is 2003 if the
2549 // other fields specify a date before 6/18, or 1903 if they specify a
2550 // date afterwards. As a result, 03 is an ambiguous year. All other
2551 // two-digit years are unambiguous.
2552 if(fHaveDefaultCentury) { // check if this formatter even has a pivot year
2553 int32_t ambiguousTwoDigitYear = fDefaultCenturyStartYear % 100;
2554 ambiguousYear[0] = (value == ambiguousTwoDigitYear);
2555 value += (fDefaultCenturyStartYear/100)*100 +
2556 (value < ambiguousTwoDigitYear ? 100 : 0);
2557 }
2558 }
2559 cal.set(UCAL_YEAR, value);
2560
2561 // Delayed checking for adjustment of Hebrew month numbers in non-leap years.
2562 if (saveHebrewMonth >= 0) {
2563 HebrewCalendar *hc = (HebrewCalendar*)&cal;
2564 if (!hc->isLeapYear(value) && saveHebrewMonth >= 6) {
2565 cal.set(UCAL_MONTH,saveHebrewMonth);
2566 } else {
2567 cal.set(UCAL_MONTH,saveHebrewMonth-1);
2568 }
2569 saveHebrewMonth = -1;
2570 }
2571 return pos.getIndex();
2572
2573 case UDAT_YEAR_WOY_FIELD:
2574 // Comment is the same as for UDAT_Year_FIELDs - look above
2575 if (fDateOverride.compare(hebr)==0 && value < 1000) {
2576 value += HEBREW_CAL_CUR_MILLENIUM_START_YEAR;
2577 } else if ((pos.getIndex() - start) == 2
2578 && u_isdigit(text.charAt(start))
2579 && u_isdigit(text.charAt(start+1))
2580 && fHaveDefaultCentury )
2581 {
2582 int32_t ambiguousTwoDigitYear = fDefaultCenturyStartYear % 100;
2583 ambiguousYear[0] = (value == ambiguousTwoDigitYear);
2584 value += (fDefaultCenturyStartYear/100)*100 +
2585 (value < ambiguousTwoDigitYear ? 100 : 0);
2586 }
2587 cal.set(UCAL_YEAR_WOY, value);
2588 return pos.getIndex();
2589
2590 case UDAT_YEAR_NAME_FIELD:
2591 if (fSymbols->fShortYearNames != NULL) {
2592 int32_t newStart = matchString(text, start, UCAL_YEAR, fSymbols->fShortYearNames, fSymbols->fShortYearNamesCount, NULL, cal);
2593 if (newStart > 0) {
2594 return newStart;
2595 }
2596 }
2597 if (gotNumber && (lenient || value > fSymbols->fShortYearNamesCount)) {
2598 cal.set(UCAL_YEAR, value);
2599 return pos.getIndex();
2600 }
2601 return -start;
2602
2603 case UDAT_MONTH_FIELD:
2604 case UDAT_STANDALONE_MONTH_FIELD:
2605 if (gotNumber) // i.e., M or MM.
2606 {
2607 // When parsing month numbers from the Hebrew Calendar, we might need to adjust the month depending on whether
2608 // or not it was a leap year. We may or may not yet know what year it is, so might have to delay checking until
2609 // the year is parsed.
2610 if (!strcmp(cal.getType(),"hebrew")) {
2611 HebrewCalendar *hc = (HebrewCalendar*)&cal;
2612 if (cal.isSet(UCAL_YEAR)) {
2613 UErrorCode status = U_ZERO_ERROR;
2614 if (!hc->isLeapYear(hc->get(UCAL_YEAR,status)) && value >= 6) {
2615 cal.set(UCAL_MONTH, value);
2616 } else {
2617 cal.set(UCAL_MONTH, value - 1);
2618 }
2619 } else {
2620 saveHebrewMonth = value;
2621 }
2622 } else {
2623 // Don't want to parse the month if it is a string
2624 // while pattern uses numeric style: M/MM, L/LL
2625 // [We computed 'value' above.]
2626 cal.set(UCAL_MONTH, value - 1);
2627 }
2628 return pos.getIndex();
2629 } else {
2630 // count >= 3 // i.e., MMM/MMMM, LLL/LLLL
2631 // Want to be able to parse both short and long forms.
2632 // Try count == 4 first:
2633 UnicodeString * wideMonthPat = NULL;
2634 UnicodeString * shortMonthPat = NULL;
2635 if (fSymbols->fLeapMonthPatterns != NULL && fSymbols->fLeapMonthPatternsCount >= DateFormatSymbols::kMonthPatternsCount) {
2636 if (patternCharIndex==UDAT_MONTH_FIELD) {
2637 wideMonthPat = &fSymbols->fLeapMonthPatterns[DateFormatSymbols::kLeapMonthPatternFormatWide];
2638 shortMonthPat = &fSymbols->fLeapMonthPatterns[DateFormatSymbols::kLeapMonthPatternFormatAbbrev];
2639 } else {
2640 wideMonthPat = &fSymbols->fLeapMonthPatterns[DateFormatSymbols::kLeapMonthPatternStandaloneWide];
2641 shortMonthPat = &fSymbols->fLeapMonthPatterns[DateFormatSymbols::kLeapMonthPatternStandaloneAbbrev];
2642 }
2643 }
2644 int32_t newStart = 0;
2645 if (patternCharIndex==UDAT_MONTH_FIELD) {
2646 newStart = matchString(text, start, UCAL_MONTH, fSymbols->fMonths, fSymbols->fMonthsCount, wideMonthPat, cal); // try MMMM
2647 if (newStart > 0) {
2648 return newStart;
2649 }
2650 newStart = matchString(text, start, UCAL_MONTH, fSymbols->fShortMonths, fSymbols->fShortMonthsCount, shortMonthPat, cal); // try MMM
2651 } else {
2652 newStart = matchString(text, start, UCAL_MONTH, fSymbols->fStandaloneMonths, fSymbols->fStandaloneMonthsCount, wideMonthPat, cal); // try LLLL
2653 if (newStart > 0) {
2654 return newStart;
2655 }
2656 newStart = matchString(text, start, UCAL_MONTH, fSymbols->fStandaloneShortMonths, fSymbols->fStandaloneShortMonthsCount, shortMonthPat, cal); // try LLL
2657 }
2658 if (newStart > 0 || !lenient) // currently we do not try to parse MMMMM/LLLLL: #8860
2659 return newStart;
2660 // else we allowing parsing as number, below
2661 }
2662 break;
2663
2664 case UDAT_HOUR_OF_DAY1_FIELD:
2665 // [We computed 'value' above.]
2666 if (value == cal.getMaximum(UCAL_HOUR_OF_DAY) + 1)
2667 value = 0;
2668
2669 // fall through to set field
2670
2671 case UDAT_HOUR_OF_DAY0_FIELD:
2672 cal.set(UCAL_HOUR_OF_DAY, value);
2673 return pos.getIndex();
2674
2675 case UDAT_FRACTIONAL_SECOND_FIELD:
2676 // Fractional seconds left-justify
2677 i = pos.getIndex() - start;
2678 if (i < 3) {
2679 while (i < 3) {
2680 value *= 10;
2681 i++;
2682 }
2683 } else {
2684 int32_t a = 1;
2685 while (i > 3) {
2686 a *= 10;
2687 i--;
2688 }
2689 value = (value + (a>>1)) / a;
2690 }
2691 cal.set(UCAL_MILLISECOND, value);
2692 return pos.getIndex();
2693
2694 case UDAT_DOW_LOCAL_FIELD:
2695 if (gotNumber) // i.e., e or ee
2696 {
2697 // [We computed 'value' above.]
2698 cal.set(UCAL_DOW_LOCAL, value);
2699 return pos.getIndex();
2700 }
2701 // else for eee-eeeee fall through to handling of EEE-EEEEE
2702 // fall through, do not break here
2703 case UDAT_DAY_OF_WEEK_FIELD:
2704 {
2705 // Want to be able to parse both short and long forms.
2706 // Try count == 4 (EEEE) first:
2707 int32_t newStart = 0;
2708 if ((newStart = matchString(text, start, UCAL_DAY_OF_WEEK,
2709 fSymbols->fWeekdays, fSymbols->fWeekdaysCount, NULL, cal)) > 0)
2710 return newStart;
2711 // EEEE failed, now try EEE
2712 else if ((newStart = matchString(text, start, UCAL_DAY_OF_WEEK,
2713 fSymbols->fShortWeekdays, fSymbols->fShortWeekdaysCount, NULL, cal)) > 0)
2714 return newStart;
2715 // EEE failed, now try EEEEE
2716 else if ((newStart = matchString(text, start, UCAL_DAY_OF_WEEK,
2717 fSymbols->fNarrowWeekdays, fSymbols->fNarrowWeekdaysCount, NULL, cal)) > 0)
2718 return newStart;
2719 else if (!lenient || patternCharIndex == UDAT_DAY_OF_WEEK_FIELD)
2720 return newStart;
2721 // else we allowing parsing as number, below
2722 }
2723 break;
2724
2725 case UDAT_STANDALONE_DAY_FIELD:
2726 {
2727 if (gotNumber) // c or cc
2728 {
2729 // [We computed 'value' above.]
2730 cal.set(UCAL_DOW_LOCAL, value);
2731 return pos.getIndex();
2732 }
2733 // Want to be able to parse both short and long forms.
2734 // Try count == 4 (cccc) first:
2735 int32_t newStart = 0;
2736 if ((newStart = matchString(text, start, UCAL_DAY_OF_WEEK,
2737 fSymbols->fStandaloneWeekdays, fSymbols->fStandaloneWeekdaysCount, NULL, cal)) > 0)
2738 return newStart;
2739 else if ((newStart = matchString(text, start, UCAL_DAY_OF_WEEK,
2740 fSymbols->fStandaloneShortWeekdays, fSymbols->fStandaloneShortWeekdaysCount, NULL, cal)) > 0)
2741 return newStart;
2742 else if (!lenient)
2743 return newStart;
2744 // else we allowing parsing as number, below
2745 }
2746 break;
2747
2748 case UDAT_AM_PM_FIELD:
2749 return matchString(text, start, UCAL_AM_PM, fSymbols->fAmPms, fSymbols->fAmPmsCount, NULL, cal);
2750
2751 case UDAT_HOUR1_FIELD:
2752 // [We computed 'value' above.]
2753 if (value == cal.getLeastMaximum(UCAL_HOUR)+1)
2754 value = 0;
2755
2756 // fall through to set field
2757
2758 case UDAT_HOUR0_FIELD:
2759 cal.set(UCAL_HOUR, value);
2760 return pos.getIndex();
2761
2762 case UDAT_QUARTER_FIELD:
2763 if (gotNumber) // i.e., Q or QQ.
2764 {
2765 // Don't want to parse the month if it is a string
2766 // while pattern uses numeric style: Q or QQ.
2767 // [We computed 'value' above.]
2768 cal.set(UCAL_MONTH, (value - 1) * 3);
2769 return pos.getIndex();
2770 } else {
2771 // count >= 3 // i.e., QQQ or QQQQ
2772 // Want to be able to parse both short and long forms.
2773 // Try count == 4 first:
2774 int32_t newStart = 0;
2775
2776 if ((newStart = matchQuarterString(text, start, UCAL_MONTH,
2777 fSymbols->fQuarters, fSymbols->fQuartersCount, cal)) > 0)
2778 return newStart;
2779 else if ((newStart = matchQuarterString(text, start, UCAL_MONTH,
2780 fSymbols->fShortQuarters, fSymbols->fShortQuartersCount, cal)) > 0)
2781 return newStart;
2782 else if (!lenient)
2783 return newStart;
2784 // else we allowing parsing as number, below
2785 }
2786 break;
2787
2788 case UDAT_STANDALONE_QUARTER_FIELD:
2789 if (gotNumber) // i.e., q or qq.
2790 {
2791 // Don't want to parse the month if it is a string
2792 // while pattern uses numeric style: q or q.
2793 // [We computed 'value' above.]
2794 cal.set(UCAL_MONTH, (value - 1) * 3);
2795 return pos.getIndex();
2796 } else {
2797 // count >= 3 // i.e., qqq or qqqq
2798 // Want to be able to parse both short and long forms.
2799 // Try count == 4 first:
2800 int32_t newStart = 0;
2801
2802 if ((newStart = matchQuarterString(text, start, UCAL_MONTH,
2803 fSymbols->fStandaloneQuarters, fSymbols->fStandaloneQuartersCount, cal)) > 0)
2804 return newStart;
2805 else if ((newStart = matchQuarterString(text, start, UCAL_MONTH,
2806 fSymbols->fStandaloneShortQuarters, fSymbols->fStandaloneShortQuartersCount, cal)) > 0)
2807 return newStart;
2808 else if (!lenient)
2809 return newStart;
2810 // else we allowing parsing as number, below
2811 }
2812 break;
2813
2814 case UDAT_TIMEZONE_FIELD:
2815 {
2816 UTimeZoneFormatTimeType tzTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
2817 UTimeZoneFormatStyle style = (count < 4) ? UTZFMT_STYLE_SPECIFIC_SHORT : UTZFMT_STYLE_SPECIFIC_LONG;
2818 TimeZone *tz = tzFormat()->parse(style, text, pos, &tzTimeType);
2819 if (tz != NULL) {
2820 ((SimpleDateFormat*)this)->tztype = tzTimeType;
2821 cal.adoptTimeZone(tz);
2822 return pos.getIndex();
2823 }
2824 }
2825 break;
2826 case UDAT_TIMEZONE_RFC_FIELD:
2827 {
2828 UTimeZoneFormatTimeType tzTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
2829 UTimeZoneFormatStyle style = (count < 4) ? UTZFMT_STYLE_RFC822 : ((count == 5) ? UTZFMT_STYLE_ISO8601: UTZFMT_STYLE_LOCALIZED_GMT);
2830 TimeZone *tz = tzFormat()->parse(style, text, pos, &tzTimeType);
2831 if (tz != NULL) {
2832 ((SimpleDateFormat*)this)->tztype = tzTimeType;
2833 cal.adoptTimeZone(tz);
2834 return pos.getIndex();
2835 }
2836 return -start;
2837 }
2838 case UDAT_TIMEZONE_GENERIC_FIELD:
2839 {
2840 UTimeZoneFormatTimeType tzTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
2841 UTimeZoneFormatStyle style = (count < 4) ? UTZFMT_STYLE_GENERIC_SHORT : UTZFMT_STYLE_GENERIC_LONG;
2842 TimeZone *tz = tzFormat()->parse(style, text, pos, &tzTimeType);
2843 if (tz != NULL) {
2844 ((SimpleDateFormat*)this)->tztype = tzTimeType;
2845 cal.adoptTimeZone(tz);
2846 return pos.getIndex();
2847 }
2848 return -start;
2849 }
2850 case UDAT_TIMEZONE_SPECIAL_FIELD:
2851 {
2852 UTimeZoneFormatTimeType tzTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
2853 UTimeZoneFormatStyle style = (count < 4) ? UTZFMT_STYLE_SPECIFIC_SHORT : UTZFMT_STYLE_GENERIC_LOCATION;
2854 TimeZone *tz = tzFormat()->parse(style, text, pos, &tzTimeType);
2855 if (tz != NULL) {
2856 ((SimpleDateFormat*)this)->tztype = tzTimeType;
2857 cal.adoptTimeZone(tz);
2858 return pos.getIndex();
2859 }
2860 return -start;
2861 }
2862
2863 default:
2864 // Handle "generic" fields
2865 // this is now handled below, outside the switch block
2866 break;
2867 }
2868 // Handle "generic" fields:
2869 // switch default case now handled here (outside switch block) to allow
2870 // parsing of some string fields as digits for lenient case
2871
2872 int32_t parseStart = pos.getIndex();
2873 const UnicodeString* src;
2874 if (obeyCount) {
2875 if ((start+count) > text.length()) {
2876 return -start;
2877 }
2878 text.extractBetween(0, start + count, temp);
2879 src = &temp;
2880 } else {
2881 src = &text;
2882 }
2883 parseInt(*src, number, pos, allowNegative,currentNumberFormat);
2884 if (pos.getIndex() != parseStart) {
2885 int32_t value = number.getLong();
2886
2887 // Don't need suffix processing here (as in number processing at the beginning of the function);
2888 // the new fields being handled as numeric values (month, weekdays, quarters) should not have suffixes.
2889
2890 if (!lenient) {
2891 // Check the range of the value
2892 int32_t bias = gFieldRangeBias[patternCharIndex];
2893 if (bias >= 0 && (value > cal.getMaximum(field) + bias || value < cal.getMinimum(field) + bias)) {
2894 return -start;
2895 }
2896 }
2897
2898 // For the following, need to repeat some of the "if (gotNumber)" code above:
2899 // UDAT_[STANDALONE_]MONTH_FIELD, UDAT_DOW_LOCAL_FIELD, UDAT_STANDALONE_DAY_FIELD,
2900 // UDAT_[STANDALONE_]QUARTER_FIELD
2901 switch (patternCharIndex) {
2902 case UDAT_MONTH_FIELD:
2903 // See notes under UDAT_MONTH_FIELD case above
2904 if (!strcmp(cal.getType(),"hebrew")) {
2905 HebrewCalendar *hc = (HebrewCalendar*)&cal;
2906 if (cal.isSet(UCAL_YEAR)) {
2907 UErrorCode status = U_ZERO_ERROR;
2908 if (!hc->isLeapYear(hc->get(UCAL_YEAR,status)) && value >= 6) {
2909 cal.set(UCAL_MONTH, value);
2910 } else {
2911 cal.set(UCAL_MONTH, value - 1);
2912 }
2913 } else {
2914 saveHebrewMonth = value;
2915 }
2916 } else {
2917 cal.set(UCAL_MONTH, value - 1);
2918 }
2919 break;
2920 case UDAT_STANDALONE_MONTH_FIELD:
2921 cal.set(UCAL_MONTH, value - 1);
2922 break;
2923 case UDAT_DOW_LOCAL_FIELD:
2924 case UDAT_STANDALONE_DAY_FIELD:
2925 cal.set(UCAL_DOW_LOCAL, value);
2926 break;
2927 case UDAT_QUARTER_FIELD:
2928 case UDAT_STANDALONE_QUARTER_FIELD:
2929 cal.set(UCAL_MONTH, (value - 1) * 3);
2930 break;
2931 default:
2932 cal.set(field, value);
2933 break;
2934 }
2935 return pos.getIndex();
2936 }
2937 return -start;
2938 }
2939
2940 /**
2941 * Parse an integer using fNumberFormat. This method is semantically
2942 * const, but actually may modify fNumberFormat.
2943 */
parseInt(const UnicodeString & text,Formattable & number,ParsePosition & pos,UBool allowNegative,NumberFormat * fmt) const2944 void SimpleDateFormat::parseInt(const UnicodeString& text,
2945 Formattable& number,
2946 ParsePosition& pos,
2947 UBool allowNegative,
2948 NumberFormat *fmt) const {
2949 parseInt(text, number, -1, pos, allowNegative,fmt);
2950 }
2951
2952 /**
2953 * Parse an integer using fNumberFormat up to maxDigits.
2954 */
parseInt(const UnicodeString & text,Formattable & number,int32_t maxDigits,ParsePosition & pos,UBool allowNegative,NumberFormat * fmt) const2955 void SimpleDateFormat::parseInt(const UnicodeString& text,
2956 Formattable& number,
2957 int32_t maxDigits,
2958 ParsePosition& pos,
2959 UBool allowNegative,
2960 NumberFormat *fmt) const {
2961 UnicodeString oldPrefix;
2962 DecimalFormat* df = NULL;
2963 if (!allowNegative && (df = dynamic_cast<DecimalFormat*>(fmt)) != NULL) {
2964 df->getNegativePrefix(oldPrefix);
2965 df->setNegativePrefix(UnicodeString(TRUE, SUPPRESS_NEGATIVE_PREFIX, -1));
2966 }
2967 int32_t oldPos = pos.getIndex();
2968 fmt->parse(text, number, pos);
2969 if (df != NULL) {
2970 df->setNegativePrefix(oldPrefix);
2971 }
2972
2973 if (maxDigits > 0) {
2974 // adjust the result to fit into
2975 // the maxDigits and move the position back
2976 int32_t nDigits = pos.getIndex() - oldPos;
2977 if (nDigits > maxDigits) {
2978 int32_t val = number.getLong();
2979 nDigits -= maxDigits;
2980 while (nDigits > 0) {
2981 val /= 10;
2982 nDigits--;
2983 }
2984 pos.setIndex(oldPos + maxDigits);
2985 number.setLong(val);
2986 }
2987 }
2988 }
2989
2990 //----------------------------------------------------------------------
2991
translatePattern(const UnicodeString & originalPattern,UnicodeString & translatedPattern,const UnicodeString & from,const UnicodeString & to,UErrorCode & status)2992 void SimpleDateFormat::translatePattern(const UnicodeString& originalPattern,
2993 UnicodeString& translatedPattern,
2994 const UnicodeString& from,
2995 const UnicodeString& to,
2996 UErrorCode& status)
2997 {
2998 // run through the pattern and convert any pattern symbols from the version
2999 // in "from" to the corresponding character ion "to". This code takes
3000 // quoted strings into account (it doesn't try to translate them), and it signals
3001 // an error if a particular "pattern character" doesn't appear in "from".
3002 // Depending on the values of "from" and "to" this can convert from generic
3003 // to localized patterns or localized to generic.
3004 if (U_FAILURE(status))
3005 return;
3006
3007 translatedPattern.remove();
3008 UBool inQuote = FALSE;
3009 for (int32_t i = 0; i < originalPattern.length(); ++i) {
3010 UChar c = originalPattern[i];
3011 if (inQuote) {
3012 if (c == QUOTE)
3013 inQuote = FALSE;
3014 }
3015 else {
3016 if (c == QUOTE)
3017 inQuote = TRUE;
3018 else if ((c >= 0x0061 /*'a'*/ && c <= 0x007A) /*'z'*/
3019 || (c >= 0x0041 /*'A'*/ && c <= 0x005A /*'Z'*/)) {
3020 int32_t ci = from.indexOf(c);
3021 if (ci == -1) {
3022 status = U_INVALID_FORMAT_ERROR;
3023 return;
3024 }
3025 c = to[ci];
3026 }
3027 }
3028 translatedPattern += c;
3029 }
3030 if (inQuote) {
3031 status = U_INVALID_FORMAT_ERROR;
3032 return;
3033 }
3034 }
3035
3036 //----------------------------------------------------------------------
3037
3038 UnicodeString&
toPattern(UnicodeString & result) const3039 SimpleDateFormat::toPattern(UnicodeString& result) const
3040 {
3041 result = fPattern;
3042 return result;
3043 }
3044
3045 //----------------------------------------------------------------------
3046
3047 UnicodeString&
toLocalizedPattern(UnicodeString & result,UErrorCode & status) const3048 SimpleDateFormat::toLocalizedPattern(UnicodeString& result,
3049 UErrorCode& status) const
3050 {
3051 translatePattern(fPattern, result,
3052 UnicodeString(DateFormatSymbols::getPatternUChars()),
3053 fSymbols->fLocalPatternChars, status);
3054 return result;
3055 }
3056
3057 //----------------------------------------------------------------------
3058
3059 void
applyPattern(const UnicodeString & pattern)3060 SimpleDateFormat::applyPattern(const UnicodeString& pattern)
3061 {
3062 fPattern = pattern;
3063 }
3064
3065 //----------------------------------------------------------------------
3066
3067 void
applyLocalizedPattern(const UnicodeString & pattern,UErrorCode & status)3068 SimpleDateFormat::applyLocalizedPattern(const UnicodeString& pattern,
3069 UErrorCode &status)
3070 {
3071 translatePattern(pattern, fPattern,
3072 fSymbols->fLocalPatternChars,
3073 UnicodeString(DateFormatSymbols::getPatternUChars()), status);
3074 }
3075
3076 //----------------------------------------------------------------------
3077
3078 const DateFormatSymbols*
getDateFormatSymbols() const3079 SimpleDateFormat::getDateFormatSymbols() const
3080 {
3081 return fSymbols;
3082 }
3083
3084 //----------------------------------------------------------------------
3085
3086 void
adoptDateFormatSymbols(DateFormatSymbols * newFormatSymbols)3087 SimpleDateFormat::adoptDateFormatSymbols(DateFormatSymbols* newFormatSymbols)
3088 {
3089 delete fSymbols;
3090 fSymbols = newFormatSymbols;
3091 }
3092
3093 //----------------------------------------------------------------------
3094 void
setDateFormatSymbols(const DateFormatSymbols & newFormatSymbols)3095 SimpleDateFormat::setDateFormatSymbols(const DateFormatSymbols& newFormatSymbols)
3096 {
3097 delete fSymbols;
3098 fSymbols = new DateFormatSymbols(newFormatSymbols);
3099 }
3100
3101 //----------------------------------------------------------------------
3102 const TimeZoneFormat*
getTimeZoneFormat(void) const3103 SimpleDateFormat::getTimeZoneFormat(void) const {
3104 return (const TimeZoneFormat*)tzFormat();
3105 }
3106
3107 //----------------------------------------------------------------------
3108 void
adoptTimeZoneFormat(TimeZoneFormat * timeZoneFormatToAdopt)3109 SimpleDateFormat::adoptTimeZoneFormat(TimeZoneFormat* timeZoneFormatToAdopt)
3110 {
3111 delete fTimeZoneFormat;
3112 fTimeZoneFormat = timeZoneFormatToAdopt;
3113 }
3114
3115 //----------------------------------------------------------------------
3116 void
setTimeZoneFormat(const TimeZoneFormat & newTimeZoneFormat)3117 SimpleDateFormat::setTimeZoneFormat(const TimeZoneFormat& newTimeZoneFormat)
3118 {
3119 delete fTimeZoneFormat;
3120 fTimeZoneFormat = new TimeZoneFormat(newTimeZoneFormat);
3121 }
3122
3123 //----------------------------------------------------------------------
3124
3125
adoptCalendar(Calendar * calendarToAdopt)3126 void SimpleDateFormat::adoptCalendar(Calendar* calendarToAdopt)
3127 {
3128 UErrorCode status = U_ZERO_ERROR;
3129 DateFormat::adoptCalendar(calendarToAdopt);
3130 delete fSymbols;
3131 fSymbols=NULL;
3132 initializeSymbols(fLocale, fCalendar, status); // we need new symbols
3133 initializeDefaultCentury(); // we need a new century (possibly)
3134 }
3135
3136
3137 //----------------------------------------------------------------------
3138
3139
setContext(UDisplayContext value,UErrorCode & status)3140 void SimpleDateFormat::setContext(UDisplayContext value, UErrorCode& status)
3141 {
3142 if (U_FAILURE(status))
3143 return;
3144 if ( (UDisplayContextType)((uint32_t)value >> 8) == UDISPCTX_TYPE_CAPITALIZATION ) {
3145 fCapitalizationContext = value;
3146 } else {
3147 status = U_ILLEGAL_ARGUMENT_ERROR;
3148 }
3149 }
3150
3151
3152 //----------------------------------------------------------------------
3153
3154
getContext(UDisplayContextType type,UErrorCode & status) const3155 UDisplayContext SimpleDateFormat::getContext(UDisplayContextType type, UErrorCode& status) const
3156 {
3157 if (U_FAILURE(status))
3158 return (UDisplayContext)0;
3159 if (type != UDISPCTX_TYPE_CAPITALIZATION) {
3160 status = U_ILLEGAL_ARGUMENT_ERROR;
3161 return (UDisplayContext)0;
3162 }
3163 return fCapitalizationContext;
3164 }
3165
3166
3167 //----------------------------------------------------------------------
3168
3169
3170 UBool
isFieldUnitIgnored(UCalendarDateFields field) const3171 SimpleDateFormat::isFieldUnitIgnored(UCalendarDateFields field) const {
3172 return isFieldUnitIgnored(fPattern, field);
3173 }
3174
3175
3176 UBool
isFieldUnitIgnored(const UnicodeString & pattern,UCalendarDateFields field)3177 SimpleDateFormat::isFieldUnitIgnored(const UnicodeString& pattern,
3178 UCalendarDateFields field) {
3179 int32_t fieldLevel = fgCalendarFieldToLevel[field];
3180 int32_t level;
3181 UChar ch;
3182 UBool inQuote = FALSE;
3183 UChar prevCh = 0;
3184 int32_t count = 0;
3185
3186 for (int32_t i = 0; i < pattern.length(); ++i) {
3187 ch = pattern[i];
3188 if (ch != prevCh && count > 0) {
3189 level = fgPatternCharToLevel[prevCh - PATTERN_CHAR_BASE];
3190 // the larger the level, the smaller the field unit.
3191 if ( fieldLevel <= level ) {
3192 return FALSE;
3193 }
3194 count = 0;
3195 }
3196 if (ch == QUOTE) {
3197 if ((i+1) < pattern.length() && pattern[i+1] == QUOTE) {
3198 ++i;
3199 } else {
3200 inQuote = ! inQuote;
3201 }
3202 }
3203 else if ( ! inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
3204 || (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
3205 prevCh = ch;
3206 ++count;
3207 }
3208 }
3209 if ( count > 0 ) {
3210 // last item
3211 level = fgPatternCharToLevel[prevCh - PATTERN_CHAR_BASE];
3212 if ( fieldLevel <= level ) {
3213 return FALSE;
3214 }
3215 }
3216 return TRUE;
3217 }
3218
3219 //----------------------------------------------------------------------
3220
3221 const Locale&
getSmpFmtLocale(void) const3222 SimpleDateFormat::getSmpFmtLocale(void) const {
3223 return fLocale;
3224 }
3225
3226 //----------------------------------------------------------------------
3227
3228 int32_t
checkIntSuffix(const UnicodeString & text,int32_t start,int32_t patLoc,UBool isNegative) const3229 SimpleDateFormat::checkIntSuffix(const UnicodeString& text, int32_t start,
3230 int32_t patLoc, UBool isNegative) const {
3231 // local variables
3232 UnicodeString suf;
3233 int32_t patternMatch;
3234 int32_t textPreMatch;
3235 int32_t textPostMatch;
3236
3237 // check that we are still in range
3238 if ( (start > text.length()) ||
3239 (start < 0) ||
3240 (patLoc < 0) ||
3241 (patLoc > fPattern.length())) {
3242 // out of range, don't advance location in text
3243 return start;
3244 }
3245
3246 // get the suffix
3247 DecimalFormat* decfmt = dynamic_cast<DecimalFormat*>(fNumberFormat);
3248 if (decfmt != NULL) {
3249 if (isNegative) {
3250 suf = decfmt->getNegativeSuffix(suf);
3251 }
3252 else {
3253 suf = decfmt->getPositiveSuffix(suf);
3254 }
3255 }
3256
3257 // check for suffix
3258 if (suf.length() <= 0) {
3259 return start;
3260 }
3261
3262 // check suffix will be encountered in the pattern
3263 patternMatch = compareSimpleAffix(suf,fPattern,patLoc);
3264
3265 // check if a suffix will be encountered in the text
3266 textPreMatch = compareSimpleAffix(suf,text,start);
3267
3268 // check if a suffix was encountered in the text
3269 textPostMatch = compareSimpleAffix(suf,text,start-suf.length());
3270
3271 // check for suffix match
3272 if ((textPreMatch >= 0) && (patternMatch >= 0) && (textPreMatch == patternMatch)) {
3273 return start;
3274 }
3275 else if ((textPostMatch >= 0) && (patternMatch >= 0) && (textPostMatch == patternMatch)) {
3276 return start - suf.length();
3277 }
3278
3279 // should not get here
3280 return start;
3281 }
3282
3283 //----------------------------------------------------------------------
3284
3285 int32_t
compareSimpleAffix(const UnicodeString & affix,const UnicodeString & input,int32_t pos) const3286 SimpleDateFormat::compareSimpleAffix(const UnicodeString& affix,
3287 const UnicodeString& input,
3288 int32_t pos) const {
3289 int32_t start = pos;
3290 for (int32_t i=0; i<affix.length(); ) {
3291 UChar32 c = affix.char32At(i);
3292 int32_t len = U16_LENGTH(c);
3293 if (PatternProps::isWhiteSpace(c)) {
3294 // We may have a pattern like: \u200F \u0020
3295 // and input text like: \u200F \u0020
3296 // Note that U+200F and U+0020 are Pattern_White_Space but only
3297 // U+0020 is UWhiteSpace. So we have to first do a direct
3298 // match of the run of Pattern_White_Space in the pattern,
3299 // then match any extra characters.
3300 UBool literalMatch = FALSE;
3301 while (pos < input.length() &&
3302 input.char32At(pos) == c) {
3303 literalMatch = TRUE;
3304 i += len;
3305 pos += len;
3306 if (i == affix.length()) {
3307 break;
3308 }
3309 c = affix.char32At(i);
3310 len = U16_LENGTH(c);
3311 if (!PatternProps::isWhiteSpace(c)) {
3312 break;
3313 }
3314 }
3315
3316 // Advance over run in pattern
3317 i = skipPatternWhiteSpace(affix, i);
3318
3319 // Advance over run in input text
3320 // Must see at least one white space char in input,
3321 // unless we've already matched some characters literally.
3322 int32_t s = pos;
3323 pos = skipUWhiteSpace(input, pos);
3324 if (pos == s && !literalMatch) {
3325 return -1;
3326 }
3327
3328 // If we skip UWhiteSpace in the input text, we need to skip it in the pattern.
3329 // Otherwise, the previous lines may have skipped over text (such as U+00A0) that
3330 // is also in the affix.
3331 i = skipUWhiteSpace(affix, i);
3332 } else {
3333 if (pos < input.length() &&
3334 input.char32At(pos) == c) {
3335 i += len;
3336 pos += len;
3337 } else {
3338 return -1;
3339 }
3340 }
3341 }
3342 return pos - start;
3343 }
3344
3345 //----------------------------------------------------------------------
3346
3347 int32_t
skipPatternWhiteSpace(const UnicodeString & text,int32_t pos) const3348 SimpleDateFormat::skipPatternWhiteSpace(const UnicodeString& text, int32_t pos) const {
3349 const UChar* s = text.getBuffer();
3350 return (int32_t)(PatternProps::skipWhiteSpace(s + pos, text.length() - pos) - s);
3351 }
3352
3353 //----------------------------------------------------------------------
3354
3355 int32_t
skipUWhiteSpace(const UnicodeString & text,int32_t pos) const3356 SimpleDateFormat::skipUWhiteSpace(const UnicodeString& text, int32_t pos) const {
3357 while (pos < text.length()) {
3358 UChar32 c = text.char32At(pos);
3359 if (!u_isUWhiteSpace(c)) {
3360 break;
3361 }
3362 pos += U16_LENGTH(c);
3363 }
3364 return pos;
3365 }
3366
3367 //----------------------------------------------------------------------
3368
3369 // Lazy TimeZoneFormat instantiation, semantically const.
3370 TimeZoneFormat *
tzFormat() const3371 SimpleDateFormat::tzFormat() const {
3372 if (fTimeZoneFormat == NULL) {
3373 umtx_lock(&LOCK);
3374 {
3375 if (fTimeZoneFormat == NULL) {
3376 UErrorCode status = U_ZERO_ERROR;
3377 TimeZoneFormat *tzfmt = TimeZoneFormat::createInstance(fLocale, status);
3378 if (U_FAILURE(status)) {
3379 return NULL;
3380 }
3381
3382 const_cast<SimpleDateFormat *>(this)->fTimeZoneFormat = tzfmt;
3383 }
3384 }
3385 umtx_unlock(&LOCK);
3386 }
3387 return fTimeZoneFormat;
3388 }
3389
3390 U_NAMESPACE_END
3391
3392 #endif /* #if !UCONFIG_NO_FORMATTING */
3393
3394 //eof
3395