1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 *******************************************************************************
5 * Copyright (C) 1997-2016, International Business Machines Corporation and *
6 * others. All Rights Reserved. *
7 *******************************************************************************
8 *
9 * File DTFMTSYM.CPP
10 *
11 * Modification History:
12 *
13 * Date Name Description
14 * 02/19/97 aliu Converted from java.
15 * 07/21/98 stephen Added getZoneIndex
16 * Changed weekdays/short weekdays to be one-based
17 * 06/14/99 stephen Removed SimpleDateFormat::fgTimeZoneDataSuffix
18 * 11/16/99 weiv Added 'Y' and 'e' to fgPatternChars
19 * 03/27/00 weiv Keeping resource bundle around!
20 * 06/30/05 emmons Added eraNames, narrow month/day, standalone context
21 * 10/12/05 emmons Added setters for eraNames, month/day by width/context
22 *******************************************************************************
23 */
24 #include "unicode/utypes.h"
25
26 #if !UCONFIG_NO_FORMATTING
27 #include "unicode/ustring.h"
28 #include "unicode/localpointer.h"
29 #include "unicode/dtfmtsym.h"
30 #include "unicode/smpdtfmt.h"
31 #include "unicode/msgfmt.h"
32 #include "unicode/numsys.h"
33 #include "unicode/tznames.h"
34 #include "cpputils.h"
35 #include "umutex.h"
36 #include "cmemory.h"
37 #include "cstring.h"
38 #include "charstr.h"
39 #include "dt_impl.h"
40 #include "locbased.h"
41 #include "gregoimp.h"
42 #include "hash.h"
43 #include "uassert.h"
44 #include "uresimp.h"
45 #include "ureslocs.h"
46 #include "uvector.h"
47 #include "shareddateformatsymbols.h"
48 #include "unicode/calendar.h"
49 #include "unifiedcache.h"
50
51 // *****************************************************************************
52 // class DateFormatSymbols
53 // *****************************************************************************
54
55 /**
56 * These are static arrays we use only in the case where we have no
57 * resource data.
58 */
59
60 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR
61 #define PATTERN_CHARS_LEN 38
62 #else
63 #define PATTERN_CHARS_LEN 37
64 #endif
65
66 /**
67 * Unlocalized date-time pattern characters. For example: 'y', 'd', etc. All
68 * locales use the same these unlocalized pattern characters.
69 */
70 static const UChar gPatternChars[] = {
71 // if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR:
72 // GyMdkHmsSEDFwWahKzYeugAZvcLQqVUOXxrbB:
73 // else:
74 // GyMdkHmsSEDFwWahKzYeugAZvcLQqVUOXxrbB
75
76 0x47, 0x79, 0x4D, 0x64, 0x6B, 0x48, 0x6D, 0x73, 0x53, 0x45,
77 0x44, 0x46, 0x77, 0x57, 0x61, 0x68, 0x4B, 0x7A, 0x59, 0x65,
78 0x75, 0x67, 0x41, 0x5A, 0x76, 0x63, 0x4c, 0x51, 0x71, 0x56,
79 0x55, 0x4F, 0x58, 0x78, 0x72, 0x62, 0x42,
80 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR
81 0x3a,
82 #endif
83 0
84 };
85
86 //------------------------------------------------------
87 // Strings of last resort. These are only used if we have no resource
88 // files. They aren't designed for actual use, just for backup.
89
90 // These are the month names and abbreviations of last resort.
91 static const UChar gLastResortMonthNames[13][3] =
92 {
93 {0x0030, 0x0031, 0x0000}, /* "01" */
94 {0x0030, 0x0032, 0x0000}, /* "02" */
95 {0x0030, 0x0033, 0x0000}, /* "03" */
96 {0x0030, 0x0034, 0x0000}, /* "04" */
97 {0x0030, 0x0035, 0x0000}, /* "05" */
98 {0x0030, 0x0036, 0x0000}, /* "06" */
99 {0x0030, 0x0037, 0x0000}, /* "07" */
100 {0x0030, 0x0038, 0x0000}, /* "08" */
101 {0x0030, 0x0039, 0x0000}, /* "09" */
102 {0x0031, 0x0030, 0x0000}, /* "10" */
103 {0x0031, 0x0031, 0x0000}, /* "11" */
104 {0x0031, 0x0032, 0x0000}, /* "12" */
105 {0x0031, 0x0033, 0x0000} /* "13" */
106 };
107
108 // These are the weekday names and abbreviations of last resort.
109 static const UChar gLastResortDayNames[8][2] =
110 {
111 {0x0030, 0x0000}, /* "0" */
112 {0x0031, 0x0000}, /* "1" */
113 {0x0032, 0x0000}, /* "2" */
114 {0x0033, 0x0000}, /* "3" */
115 {0x0034, 0x0000}, /* "4" */
116 {0x0035, 0x0000}, /* "5" */
117 {0x0036, 0x0000}, /* "6" */
118 {0x0037, 0x0000} /* "7" */
119 };
120
121 // These are the quarter names and abbreviations of last resort.
122 static const UChar gLastResortQuarters[4][2] =
123 {
124 {0x0031, 0x0000}, /* "1" */
125 {0x0032, 0x0000}, /* "2" */
126 {0x0033, 0x0000}, /* "3" */
127 {0x0034, 0x0000}, /* "4" */
128 };
129
130 // These are the am/pm and BC/AD markers of last resort.
131 static const UChar gLastResortAmPmMarkers[2][3] =
132 {
133 {0x0041, 0x004D, 0x0000}, /* "AM" */
134 {0x0050, 0x004D, 0x0000} /* "PM" */
135 };
136
137 static const UChar gLastResortEras[2][3] =
138 {
139 {0x0042, 0x0043, 0x0000}, /* "BC" */
140 {0x0041, 0x0044, 0x0000} /* "AD" */
141 };
142
143 /* Sizes for the last resort string arrays */
144 typedef enum LastResortSize {
145 kMonthNum = 13,
146 kMonthLen = 3,
147
148 kDayNum = 8,
149 kDayLen = 2,
150
151 kAmPmNum = 2,
152 kAmPmLen = 3,
153
154 kQuarterNum = 4,
155 kQuarterLen = 2,
156
157 kEraNum = 2,
158 kEraLen = 3,
159
160 kZoneNum = 5,
161 kZoneLen = 4,
162
163 kGmtHourNum = 4,
164 kGmtHourLen = 10
165 } LastResortSize;
166
167 U_NAMESPACE_BEGIN
168
~SharedDateFormatSymbols()169 SharedDateFormatSymbols::~SharedDateFormatSymbols() {
170 }
171
172 template<> U_I18N_API
173 const SharedDateFormatSymbols *
createObject(const void *,UErrorCode & status) const174 LocaleCacheKey<SharedDateFormatSymbols>::createObject(
175 const void * /*unusedContext*/, UErrorCode &status) const {
176 char type[256];
177 Calendar::getCalendarTypeFromLocale(fLoc, type, UPRV_LENGTHOF(type), status);
178 if (U_FAILURE(status)) {
179 return NULL;
180 }
181 SharedDateFormatSymbols *shared
182 = new SharedDateFormatSymbols(fLoc, type, status);
183 if (shared == NULL) {
184 status = U_MEMORY_ALLOCATION_ERROR;
185 return NULL;
186 }
187 if (U_FAILURE(status)) {
188 delete shared;
189 return NULL;
190 }
191 shared->addRef();
192 return shared;
193 }
194
195 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateFormatSymbols)
196
197 #define kSUPPLEMENTAL "supplementalData"
198
199 /**
200 * These are the tags we expect to see in normal resource bundle files associated
201 * with a locale and calendar
202 */
203 static const char gCalendarTag[]="calendar";
204 static const char gGregorianTag[]="gregorian";
205 static const char gErasTag[]="eras";
206 static const char gCyclicNameSetsTag[]="cyclicNameSets";
207 static const char gNameSetYearsTag[]="years";
208 static const char gNameSetZodiacsTag[]="zodiacs";
209 static const char gMonthNamesTag[]="monthNames";
210 static const char gMonthPatternsTag[]="monthPatterns";
211 static const char gDayNamesTag[]="dayNames";
212 static const char gNamesWideTag[]="wide";
213 static const char gNamesAbbrTag[]="abbreviated";
214 static const char gNamesShortTag[]="short";
215 static const char gNamesNarrowTag[]="narrow";
216 static const char gNamesAllTag[]="all";
217 static const char gNamesFormatTag[]="format";
218 static const char gNamesStandaloneTag[]="stand-alone";
219 static const char gNamesNumericTag[]="numeric";
220 static const char gAmPmMarkersTag[]="AmPmMarkers";
221 static const char gAmPmMarkersAbbrTag[]="AmPmMarkersAbbr";
222 static const char gAmPmMarkersNarrowTag[]="AmPmMarkersNarrow";
223 static const char gQuartersTag[]="quarters";
224 static const char gNumberElementsTag[]="NumberElements";
225 static const char gSymbolsTag[]="symbols";
226 static const char gTimeSeparatorTag[]="timeSeparator";
227 static const char gDayPeriodTag[]="dayPeriod";
228
229 // static const char gZoneStringsTag[]="zoneStrings";
230
231 // static const char gLocalPatternCharsTag[]="localPatternChars";
232
233 static const char gContextTransformsTag[]="contextTransforms";
234
235 static UMutex LOCK = U_MUTEX_INITIALIZER;
236
237 /**
238 * Jitterbug 2974: MSVC has a bug whereby new X[0] behaves badly.
239 * Work around this.
240 */
newUnicodeStringArray(size_t count)241 static inline UnicodeString* newUnicodeStringArray(size_t count) {
242 return new UnicodeString[count ? count : 1];
243 }
244
245 //------------------------------------------------------
246
247 DateFormatSymbols * U_EXPORT2
createForLocale(const Locale & locale,UErrorCode & status)248 DateFormatSymbols::createForLocale(
249 const Locale& locale, UErrorCode &status) {
250 const SharedDateFormatSymbols *shared = NULL;
251 UnifiedCache::getByLocale(locale, shared, status);
252 if (U_FAILURE(status)) {
253 return NULL;
254 }
255 DateFormatSymbols *result = new DateFormatSymbols(shared->get());
256 shared->removeRef();
257 if (result == NULL) {
258 status = U_MEMORY_ALLOCATION_ERROR;
259 return NULL;
260 }
261 return result;
262 }
263
DateFormatSymbols(const Locale & locale,UErrorCode & status)264 DateFormatSymbols::DateFormatSymbols(const Locale& locale,
265 UErrorCode& status)
266 : UObject()
267 {
268 initializeData(locale, NULL, status);
269 }
270
DateFormatSymbols(UErrorCode & status)271 DateFormatSymbols::DateFormatSymbols(UErrorCode& status)
272 : UObject()
273 {
274 initializeData(Locale::getDefault(), NULL, status, TRUE);
275 }
276
277
DateFormatSymbols(const Locale & locale,const char * type,UErrorCode & status)278 DateFormatSymbols::DateFormatSymbols(const Locale& locale,
279 const char *type,
280 UErrorCode& status)
281 : UObject()
282 {
283 initializeData(locale, type, status);
284 }
285
DateFormatSymbols(const char * type,UErrorCode & status)286 DateFormatSymbols::DateFormatSymbols(const char *type, UErrorCode& status)
287 : UObject()
288 {
289 initializeData(Locale::getDefault(), type, status, TRUE);
290 }
291
DateFormatSymbols(const DateFormatSymbols & other)292 DateFormatSymbols::DateFormatSymbols(const DateFormatSymbols& other)
293 : UObject(other)
294 {
295 copyData(other);
296 }
297
298 void
assignArray(UnicodeString * & dstArray,int32_t & dstCount,const UnicodeString * srcArray,int32_t srcCount)299 DateFormatSymbols::assignArray(UnicodeString*& dstArray,
300 int32_t& dstCount,
301 const UnicodeString* srcArray,
302 int32_t srcCount)
303 {
304 // assignArray() is only called by copyData() and initializeData(), which in turn
305 // implements the copy constructor and the assignment operator.
306 // All strings in a DateFormatSymbols object are created in one of the following
307 // three ways that all allow to safely use UnicodeString::fastCopyFrom():
308 // - readonly-aliases from resource bundles
309 // - readonly-aliases or allocated strings from constants
310 // - safely cloned strings (with owned buffers) from setXYZ() functions
311 //
312 // Note that this is true for as long as DateFormatSymbols can be constructed
313 // only from a locale bundle or set via the cloning API,
314 // *and* for as long as all the strings are in *private* fields, preventing
315 // a subclass from creating these strings in an "unsafe" way (with respect to fastCopyFrom()).
316 dstCount = srcCount;
317 dstArray = newUnicodeStringArray(srcCount);
318 if(dstArray != NULL) {
319 int32_t i;
320 for(i=0; i<srcCount; ++i) {
321 dstArray[i].fastCopyFrom(srcArray[i]);
322 }
323 }
324 }
325
326 /**
327 * Create a copy, in fZoneStrings, of the given zone strings array. The
328 * member variables fZoneStringsRowCount and fZoneStringsColCount should
329 * be set already by the caller.
330 */
331 void
createZoneStrings(const UnicodeString * const * otherStrings)332 DateFormatSymbols::createZoneStrings(const UnicodeString *const * otherStrings)
333 {
334 int32_t row, col;
335 UBool failed = FALSE;
336
337 fZoneStrings = (UnicodeString **)uprv_malloc(fZoneStringsRowCount * sizeof(UnicodeString *));
338 if (fZoneStrings != NULL) {
339 for (row=0; row<fZoneStringsRowCount; ++row)
340 {
341 fZoneStrings[row] = newUnicodeStringArray(fZoneStringsColCount);
342 if (fZoneStrings[row] == NULL) {
343 failed = TRUE;
344 break;
345 }
346 for (col=0; col<fZoneStringsColCount; ++col) {
347 // fastCopyFrom() - see assignArray comments
348 fZoneStrings[row][col].fastCopyFrom(otherStrings[row][col]);
349 }
350 }
351 }
352 // If memory allocation failed, roll back and delete fZoneStrings
353 if (failed) {
354 for (int i = row; i >= 0; i--) {
355 delete[] fZoneStrings[i];
356 }
357 uprv_free(fZoneStrings);
358 fZoneStrings = NULL;
359 }
360 }
361
362 /**
363 * Copy all of the other's data to this.
364 */
365 void
copyData(const DateFormatSymbols & other)366 DateFormatSymbols::copyData(const DateFormatSymbols& other) {
367 UErrorCode status = U_ZERO_ERROR;
368 U_LOCALE_BASED(locBased, *this);
369 locBased.setLocaleIDs(
370 other.getLocale(ULOC_VALID_LOCALE, status),
371 other.getLocale(ULOC_ACTUAL_LOCALE, status));
372 assignArray(fEras, fErasCount, other.fEras, other.fErasCount);
373 assignArray(fEraNames, fEraNamesCount, other.fEraNames, other.fEraNamesCount);
374 assignArray(fNarrowEras, fNarrowErasCount, other.fNarrowEras, other.fNarrowErasCount);
375 assignArray(fMonths, fMonthsCount, other.fMonths, other.fMonthsCount);
376 assignArray(fShortMonths, fShortMonthsCount, other.fShortMonths, other.fShortMonthsCount);
377 assignArray(fNarrowMonths, fNarrowMonthsCount, other.fNarrowMonths, other.fNarrowMonthsCount);
378 assignArray(fStandaloneMonths, fStandaloneMonthsCount, other.fStandaloneMonths, other.fStandaloneMonthsCount);
379 assignArray(fStandaloneShortMonths, fStandaloneShortMonthsCount, other.fStandaloneShortMonths, other.fStandaloneShortMonthsCount);
380 assignArray(fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, other.fStandaloneNarrowMonths, other.fStandaloneNarrowMonthsCount);
381 assignArray(fWeekdays, fWeekdaysCount, other.fWeekdays, other.fWeekdaysCount);
382 assignArray(fShortWeekdays, fShortWeekdaysCount, other.fShortWeekdays, other.fShortWeekdaysCount);
383 assignArray(fShorterWeekdays, fShorterWeekdaysCount, other.fShorterWeekdays, other.fShorterWeekdaysCount);
384 assignArray(fNarrowWeekdays, fNarrowWeekdaysCount, other.fNarrowWeekdays, other.fNarrowWeekdaysCount);
385 assignArray(fStandaloneWeekdays, fStandaloneWeekdaysCount, other.fStandaloneWeekdays, other.fStandaloneWeekdaysCount);
386 assignArray(fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount, other.fStandaloneShortWeekdays, other.fStandaloneShortWeekdaysCount);
387 assignArray(fStandaloneShorterWeekdays, fStandaloneShorterWeekdaysCount, other.fStandaloneShorterWeekdays, other.fStandaloneShorterWeekdaysCount);
388 assignArray(fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, other.fStandaloneNarrowWeekdays, other.fStandaloneNarrowWeekdaysCount);
389 assignArray(fAmPms, fAmPmsCount, other.fAmPms, other.fAmPmsCount);
390 assignArray(fNarrowAmPms, fNarrowAmPmsCount, other.fNarrowAmPms, other.fNarrowAmPmsCount );
391 fTimeSeparator.fastCopyFrom(other.fTimeSeparator); // fastCopyFrom() - see assignArray comments
392 assignArray(fQuarters, fQuartersCount, other.fQuarters, other.fQuartersCount);
393 assignArray(fShortQuarters, fShortQuartersCount, other.fShortQuarters, other.fShortQuartersCount);
394 assignArray(fStandaloneQuarters, fStandaloneQuartersCount, other.fStandaloneQuarters, other.fStandaloneQuartersCount);
395 assignArray(fStandaloneShortQuarters, fStandaloneShortQuartersCount, other.fStandaloneShortQuarters, other.fStandaloneShortQuartersCount);
396 assignArray(fWideDayPeriods, fWideDayPeriodsCount,
397 other.fWideDayPeriods, other.fWideDayPeriodsCount);
398 assignArray(fNarrowDayPeriods, fNarrowDayPeriodsCount,
399 other.fNarrowDayPeriods, other.fNarrowDayPeriodsCount);
400 assignArray(fAbbreviatedDayPeriods, fAbbreviatedDayPeriodsCount,
401 other.fAbbreviatedDayPeriods, other.fAbbreviatedDayPeriodsCount);
402 assignArray(fStandaloneWideDayPeriods, fStandaloneWideDayPeriodsCount,
403 other.fStandaloneWideDayPeriods, other.fStandaloneWideDayPeriodsCount);
404 assignArray(fStandaloneNarrowDayPeriods, fStandaloneNarrowDayPeriodsCount,
405 other.fStandaloneNarrowDayPeriods, other.fStandaloneNarrowDayPeriodsCount);
406 assignArray(fStandaloneAbbreviatedDayPeriods, fStandaloneAbbreviatedDayPeriodsCount,
407 other.fStandaloneAbbreviatedDayPeriods, other.fStandaloneAbbreviatedDayPeriodsCount);
408 if (other.fLeapMonthPatterns != NULL) {
409 assignArray(fLeapMonthPatterns, fLeapMonthPatternsCount, other.fLeapMonthPatterns, other.fLeapMonthPatternsCount);
410 } else {
411 fLeapMonthPatterns = NULL;
412 fLeapMonthPatternsCount = 0;
413 }
414 if (other.fShortYearNames != NULL) {
415 assignArray(fShortYearNames, fShortYearNamesCount, other.fShortYearNames, other.fShortYearNamesCount);
416 } else {
417 fShortYearNames = NULL;
418 fShortYearNamesCount = 0;
419 }
420 if (other.fShortZodiacNames != NULL) {
421 assignArray(fShortZodiacNames, fShortZodiacNamesCount, other.fShortZodiacNames, other.fShortZodiacNamesCount);
422 } else {
423 fShortZodiacNames = NULL;
424 fShortZodiacNamesCount = 0;
425 }
426
427 if (other.fZoneStrings != NULL) {
428 fZoneStringsColCount = other.fZoneStringsColCount;
429 fZoneStringsRowCount = other.fZoneStringsRowCount;
430 createZoneStrings((const UnicodeString**)other.fZoneStrings);
431
432 } else {
433 fZoneStrings = NULL;
434 fZoneStringsColCount = 0;
435 fZoneStringsRowCount = 0;
436 }
437 fZSFLocale = other.fZSFLocale;
438 // Other zone strings data is created on demand
439 fLocaleZoneStrings = NULL;
440
441 // fastCopyFrom() - see assignArray comments
442 fLocalPatternChars.fastCopyFrom(other.fLocalPatternChars);
443
444 uprv_memcpy(fCapitalization, other.fCapitalization, sizeof(fCapitalization));
445 }
446
447 /**
448 * Assignment operator.
449 */
operator =(const DateFormatSymbols & other)450 DateFormatSymbols& DateFormatSymbols::operator=(const DateFormatSymbols& other)
451 {
452 dispose();
453 copyData(other);
454
455 return *this;
456 }
457
~DateFormatSymbols()458 DateFormatSymbols::~DateFormatSymbols()
459 {
460 dispose();
461 }
462
dispose()463 void DateFormatSymbols::dispose()
464 {
465 delete[] fEras;
466 delete[] fEraNames;
467 delete[] fNarrowEras;
468 delete[] fMonths;
469 delete[] fShortMonths;
470 delete[] fNarrowMonths;
471 delete[] fStandaloneMonths;
472 delete[] fStandaloneShortMonths;
473 delete[] fStandaloneNarrowMonths;
474 delete[] fWeekdays;
475 delete[] fShortWeekdays;
476 delete[] fShorterWeekdays;
477 delete[] fNarrowWeekdays;
478 delete[] fStandaloneWeekdays;
479 delete[] fStandaloneShortWeekdays;
480 delete[] fStandaloneShorterWeekdays;
481 delete[] fStandaloneNarrowWeekdays;
482 delete[] fAmPms;
483 delete[] fNarrowAmPms;
484 delete[] fQuarters;
485 delete[] fShortQuarters;
486 delete[] fStandaloneQuarters;
487 delete[] fStandaloneShortQuarters;
488 delete[] fLeapMonthPatterns;
489 delete[] fShortYearNames;
490 delete[] fShortZodiacNames;
491 delete[] fAbbreviatedDayPeriods;
492 delete[] fWideDayPeriods;
493 delete[] fNarrowDayPeriods;
494 delete[] fStandaloneAbbreviatedDayPeriods;
495 delete[] fStandaloneWideDayPeriods;
496 delete[] fStandaloneNarrowDayPeriods;
497
498 disposeZoneStrings();
499 }
500
disposeZoneStrings()501 void DateFormatSymbols::disposeZoneStrings()
502 {
503 if (fZoneStrings) {
504 for (int32_t row = 0; row < fZoneStringsRowCount; ++row) {
505 delete[] fZoneStrings[row];
506 }
507 uprv_free(fZoneStrings);
508 }
509 if (fLocaleZoneStrings) {
510 for (int32_t row = 0; row < fZoneStringsRowCount; ++row) {
511 delete[] fLocaleZoneStrings[row];
512 }
513 uprv_free(fLocaleZoneStrings);
514 }
515
516 fZoneStrings = NULL;
517 fLocaleZoneStrings = NULL;
518 fZoneStringsRowCount = 0;
519 fZoneStringsColCount = 0;
520 }
521
522 UBool
arrayCompare(const UnicodeString * array1,const UnicodeString * array2,int32_t count)523 DateFormatSymbols::arrayCompare(const UnicodeString* array1,
524 const UnicodeString* array2,
525 int32_t count)
526 {
527 if (array1 == array2) return TRUE;
528 while (count>0)
529 {
530 --count;
531 if (array1[count] != array2[count]) return FALSE;
532 }
533 return TRUE;
534 }
535
536 UBool
operator ==(const DateFormatSymbols & other) const537 DateFormatSymbols::operator==(const DateFormatSymbols& other) const
538 {
539 // First do cheap comparisons
540 if (this == &other) {
541 return TRUE;
542 }
543 if (fErasCount == other.fErasCount &&
544 fEraNamesCount == other.fEraNamesCount &&
545 fNarrowErasCount == other.fNarrowErasCount &&
546 fMonthsCount == other.fMonthsCount &&
547 fShortMonthsCount == other.fShortMonthsCount &&
548 fNarrowMonthsCount == other.fNarrowMonthsCount &&
549 fStandaloneMonthsCount == other.fStandaloneMonthsCount &&
550 fStandaloneShortMonthsCount == other.fStandaloneShortMonthsCount &&
551 fStandaloneNarrowMonthsCount == other.fStandaloneNarrowMonthsCount &&
552 fWeekdaysCount == other.fWeekdaysCount &&
553 fShortWeekdaysCount == other.fShortWeekdaysCount &&
554 fShorterWeekdaysCount == other.fShorterWeekdaysCount &&
555 fNarrowWeekdaysCount == other.fNarrowWeekdaysCount &&
556 fStandaloneWeekdaysCount == other.fStandaloneWeekdaysCount &&
557 fStandaloneShortWeekdaysCount == other.fStandaloneShortWeekdaysCount &&
558 fStandaloneShorterWeekdaysCount == other.fStandaloneShorterWeekdaysCount &&
559 fStandaloneNarrowWeekdaysCount == other.fStandaloneNarrowWeekdaysCount &&
560 fAmPmsCount == other.fAmPmsCount &&
561 fNarrowAmPmsCount == other.fNarrowAmPmsCount &&
562 fQuartersCount == other.fQuartersCount &&
563 fShortQuartersCount == other.fShortQuartersCount &&
564 fStandaloneQuartersCount == other.fStandaloneQuartersCount &&
565 fStandaloneShortQuartersCount == other.fStandaloneShortQuartersCount &&
566 fLeapMonthPatternsCount == other.fLeapMonthPatternsCount &&
567 fShortYearNamesCount == other.fShortYearNamesCount &&
568 fShortZodiacNamesCount == other.fShortZodiacNamesCount &&
569 fAbbreviatedDayPeriodsCount == other.fAbbreviatedDayPeriodsCount &&
570 fWideDayPeriodsCount == other.fWideDayPeriodsCount &&
571 fNarrowDayPeriodsCount == other.fNarrowDayPeriodsCount &&
572 fStandaloneAbbreviatedDayPeriodsCount == other.fStandaloneAbbreviatedDayPeriodsCount &&
573 fStandaloneWideDayPeriodsCount == other.fStandaloneWideDayPeriodsCount &&
574 fStandaloneNarrowDayPeriodsCount == other.fStandaloneNarrowDayPeriodsCount &&
575 (uprv_memcmp(fCapitalization, other.fCapitalization, sizeof(fCapitalization))==0))
576 {
577 // Now compare the arrays themselves
578 if (arrayCompare(fEras, other.fEras, fErasCount) &&
579 arrayCompare(fEraNames, other.fEraNames, fEraNamesCount) &&
580 arrayCompare(fNarrowEras, other.fNarrowEras, fNarrowErasCount) &&
581 arrayCompare(fMonths, other.fMonths, fMonthsCount) &&
582 arrayCompare(fShortMonths, other.fShortMonths, fShortMonthsCount) &&
583 arrayCompare(fNarrowMonths, other.fNarrowMonths, fNarrowMonthsCount) &&
584 arrayCompare(fStandaloneMonths, other.fStandaloneMonths, fStandaloneMonthsCount) &&
585 arrayCompare(fStandaloneShortMonths, other.fStandaloneShortMonths, fStandaloneShortMonthsCount) &&
586 arrayCompare(fStandaloneNarrowMonths, other.fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount) &&
587 arrayCompare(fWeekdays, other.fWeekdays, fWeekdaysCount) &&
588 arrayCompare(fShortWeekdays, other.fShortWeekdays, fShortWeekdaysCount) &&
589 arrayCompare(fShorterWeekdays, other.fShorterWeekdays, fShorterWeekdaysCount) &&
590 arrayCompare(fNarrowWeekdays, other.fNarrowWeekdays, fNarrowWeekdaysCount) &&
591 arrayCompare(fStandaloneWeekdays, other.fStandaloneWeekdays, fStandaloneWeekdaysCount) &&
592 arrayCompare(fStandaloneShortWeekdays, other.fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount) &&
593 arrayCompare(fStandaloneShorterWeekdays, other.fStandaloneShorterWeekdays, fStandaloneShorterWeekdaysCount) &&
594 arrayCompare(fStandaloneNarrowWeekdays, other.fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount) &&
595 arrayCompare(fAmPms, other.fAmPms, fAmPmsCount) &&
596 arrayCompare(fNarrowAmPms, other.fNarrowAmPms, fNarrowAmPmsCount) &&
597 fTimeSeparator == other.fTimeSeparator &&
598 arrayCompare(fQuarters, other.fQuarters, fQuartersCount) &&
599 arrayCompare(fShortQuarters, other.fShortQuarters, fShortQuartersCount) &&
600 arrayCompare(fStandaloneQuarters, other.fStandaloneQuarters, fStandaloneQuartersCount) &&
601 arrayCompare(fStandaloneShortQuarters, other.fStandaloneShortQuarters, fStandaloneShortQuartersCount) &&
602 arrayCompare(fLeapMonthPatterns, other.fLeapMonthPatterns, fLeapMonthPatternsCount) &&
603 arrayCompare(fShortYearNames, other.fShortYearNames, fShortYearNamesCount) &&
604 arrayCompare(fShortZodiacNames, other.fShortZodiacNames, fShortZodiacNamesCount) &&
605 arrayCompare(fAbbreviatedDayPeriods, other.fAbbreviatedDayPeriods, fAbbreviatedDayPeriodsCount) &&
606 arrayCompare(fWideDayPeriods, other.fWideDayPeriods, fWideDayPeriodsCount) &&
607 arrayCompare(fNarrowDayPeriods, other.fNarrowDayPeriods, fNarrowDayPeriodsCount) &&
608 arrayCompare(fStandaloneAbbreviatedDayPeriods, other.fStandaloneAbbreviatedDayPeriods,
609 fStandaloneAbbreviatedDayPeriodsCount) &&
610 arrayCompare(fStandaloneWideDayPeriods, other.fStandaloneWideDayPeriods,
611 fStandaloneWideDayPeriodsCount) &&
612 arrayCompare(fStandaloneNarrowDayPeriods, other.fStandaloneNarrowDayPeriods,
613 fStandaloneWideDayPeriodsCount))
614 {
615 // Compare the contents of fZoneStrings
616 if (fZoneStrings == NULL && other.fZoneStrings == NULL) {
617 if (fZSFLocale == other.fZSFLocale) {
618 return TRUE;
619 }
620 } else if (fZoneStrings != NULL && other.fZoneStrings != NULL) {
621 if (fZoneStringsRowCount == other.fZoneStringsRowCount
622 && fZoneStringsColCount == other.fZoneStringsColCount) {
623 UBool cmpres = TRUE;
624 for (int32_t i = 0; (i < fZoneStringsRowCount) && cmpres; i++) {
625 cmpres = arrayCompare(fZoneStrings[i], other.fZoneStrings[i], fZoneStringsColCount);
626 }
627 return cmpres;
628 }
629 }
630 return FALSE;
631 }
632 }
633 return FALSE;
634 }
635
636 //------------------------------------------------------
637
638 const UnicodeString*
getEras(int32_t & count) const639 DateFormatSymbols::getEras(int32_t &count) const
640 {
641 count = fErasCount;
642 return fEras;
643 }
644
645 const UnicodeString*
getEraNames(int32_t & count) const646 DateFormatSymbols::getEraNames(int32_t &count) const
647 {
648 count = fEraNamesCount;
649 return fEraNames;
650 }
651
652 const UnicodeString*
getNarrowEras(int32_t & count) const653 DateFormatSymbols::getNarrowEras(int32_t &count) const
654 {
655 count = fNarrowErasCount;
656 return fNarrowEras;
657 }
658
659 const UnicodeString*
getMonths(int32_t & count) const660 DateFormatSymbols::getMonths(int32_t &count) const
661 {
662 count = fMonthsCount;
663 return fMonths;
664 }
665
666 const UnicodeString*
getShortMonths(int32_t & count) const667 DateFormatSymbols::getShortMonths(int32_t &count) const
668 {
669 count = fShortMonthsCount;
670 return fShortMonths;
671 }
672
673 const UnicodeString*
getMonths(int32_t & count,DtContextType context,DtWidthType width) const674 DateFormatSymbols::getMonths(int32_t &count, DtContextType context, DtWidthType width ) const
675 {
676 UnicodeString *returnValue = NULL;
677
678 switch (context) {
679 case FORMAT :
680 switch(width) {
681 case WIDE :
682 count = fMonthsCount;
683 returnValue = fMonths;
684 break;
685 case ABBREVIATED :
686 case SHORT : // no month data for this, defaults to ABBREVIATED
687 count = fShortMonthsCount;
688 returnValue = fShortMonths;
689 break;
690 case NARROW :
691 count = fNarrowMonthsCount;
692 returnValue = fNarrowMonths;
693 break;
694 case DT_WIDTH_COUNT :
695 break;
696 }
697 break;
698 case STANDALONE :
699 switch(width) {
700 case WIDE :
701 count = fStandaloneMonthsCount;
702 returnValue = fStandaloneMonths;
703 break;
704 case ABBREVIATED :
705 case SHORT : // no month data for this, defaults to ABBREVIATED
706 count = fStandaloneShortMonthsCount;
707 returnValue = fStandaloneShortMonths;
708 break;
709 case NARROW :
710 count = fStandaloneNarrowMonthsCount;
711 returnValue = fStandaloneNarrowMonths;
712 break;
713 case DT_WIDTH_COUNT :
714 break;
715 }
716 break;
717 case DT_CONTEXT_COUNT :
718 break;
719 }
720 return returnValue;
721 }
722
723 const UnicodeString*
getWeekdays(int32_t & count) const724 DateFormatSymbols::getWeekdays(int32_t &count) const
725 {
726 count = fWeekdaysCount;
727 return fWeekdays;
728 }
729
730 const UnicodeString*
getShortWeekdays(int32_t & count) const731 DateFormatSymbols::getShortWeekdays(int32_t &count) const
732 {
733 count = fShortWeekdaysCount;
734 return fShortWeekdays;
735 }
736
737 const UnicodeString*
getWeekdays(int32_t & count,DtContextType context,DtWidthType width) const738 DateFormatSymbols::getWeekdays(int32_t &count, DtContextType context, DtWidthType width) const
739 {
740 UnicodeString *returnValue = NULL;
741 switch (context) {
742 case FORMAT :
743 switch(width) {
744 case WIDE :
745 count = fWeekdaysCount;
746 returnValue = fWeekdays;
747 break;
748 case ABBREVIATED :
749 count = fShortWeekdaysCount;
750 returnValue = fShortWeekdays;
751 break;
752 case SHORT :
753 count = fShorterWeekdaysCount;
754 returnValue = fShorterWeekdays;
755 break;
756 case NARROW :
757 count = fNarrowWeekdaysCount;
758 returnValue = fNarrowWeekdays;
759 break;
760 case DT_WIDTH_COUNT :
761 break;
762 }
763 break;
764 case STANDALONE :
765 switch(width) {
766 case WIDE :
767 count = fStandaloneWeekdaysCount;
768 returnValue = fStandaloneWeekdays;
769 break;
770 case ABBREVIATED :
771 count = fStandaloneShortWeekdaysCount;
772 returnValue = fStandaloneShortWeekdays;
773 break;
774 case SHORT :
775 count = fStandaloneShorterWeekdaysCount;
776 returnValue = fStandaloneShorterWeekdays;
777 break;
778 case NARROW :
779 count = fStandaloneNarrowWeekdaysCount;
780 returnValue = fStandaloneNarrowWeekdays;
781 break;
782 case DT_WIDTH_COUNT :
783 break;
784 }
785 break;
786 case DT_CONTEXT_COUNT :
787 break;
788 }
789 return returnValue;
790 }
791
792 const UnicodeString*
getQuarters(int32_t & count,DtContextType context,DtWidthType width) const793 DateFormatSymbols::getQuarters(int32_t &count, DtContextType context, DtWidthType width ) const
794 {
795 UnicodeString *returnValue = NULL;
796
797 switch (context) {
798 case FORMAT :
799 switch(width) {
800 case WIDE :
801 count = fQuartersCount;
802 returnValue = fQuarters;
803 break;
804 case ABBREVIATED :
805 case SHORT : // no quarter data for this, defaults to ABBREVIATED
806 count = fShortQuartersCount;
807 returnValue = fShortQuarters;
808 break;
809 case NARROW :
810 count = 0;
811 returnValue = NULL;
812 break;
813 case DT_WIDTH_COUNT :
814 break;
815 }
816 break;
817 case STANDALONE :
818 switch(width) {
819 case WIDE :
820 count = fStandaloneQuartersCount;
821 returnValue = fStandaloneQuarters;
822 break;
823 case ABBREVIATED :
824 case SHORT : // no quarter data for this, defaults to ABBREVIATED
825 count = fStandaloneShortQuartersCount;
826 returnValue = fStandaloneShortQuarters;
827 break;
828 case NARROW :
829 count = 0;
830 returnValue = NULL;
831 break;
832 case DT_WIDTH_COUNT :
833 break;
834 }
835 break;
836 case DT_CONTEXT_COUNT :
837 break;
838 }
839 return returnValue;
840 }
841
842 UnicodeString&
getTimeSeparatorString(UnicodeString & result) const843 DateFormatSymbols::getTimeSeparatorString(UnicodeString& result) const
844 {
845 // fastCopyFrom() - see assignArray comments
846 return result.fastCopyFrom(fTimeSeparator);
847 }
848
849 const UnicodeString*
getAmPmStrings(int32_t & count) const850 DateFormatSymbols::getAmPmStrings(int32_t &count) const
851 {
852 count = fAmPmsCount;
853 return fAmPms;
854 }
855
856 const UnicodeString*
getLeapMonthPatterns(int32_t & count) const857 DateFormatSymbols::getLeapMonthPatterns(int32_t &count) const
858 {
859 count = fLeapMonthPatternsCount;
860 return fLeapMonthPatterns;
861 }
862
863 const UnicodeString*
getYearNames(int32_t & count,DtContextType,DtWidthType) const864 DateFormatSymbols::getYearNames(int32_t& count,
865 DtContextType /*ignored*/, DtWidthType /*ignored*/) const
866 {
867 count = fShortYearNamesCount;
868 return fShortYearNames;
869 }
870
871 void
setYearNames(const UnicodeString * yearNames,int32_t count,DtContextType context,DtWidthType width)872 DateFormatSymbols::setYearNames(const UnicodeString* yearNames, int32_t count,
873 DtContextType context, DtWidthType width)
874 {
875 if (context == FORMAT && width == ABBREVIATED) {
876 if (fShortYearNames) {
877 delete[] fShortYearNames;
878 }
879 fShortYearNames = newUnicodeStringArray(count);
880 uprv_arrayCopy(yearNames, fShortYearNames, count);
881 fShortYearNamesCount = count;
882 }
883 }
884
885 const UnicodeString*
getZodiacNames(int32_t & count,DtContextType,DtWidthType) const886 DateFormatSymbols::getZodiacNames(int32_t& count,
887 DtContextType /*ignored*/, DtWidthType /*ignored*/) const
888 {
889 count = fShortZodiacNamesCount;
890 return fShortZodiacNames;
891 }
892
893 void
setZodiacNames(const UnicodeString * zodiacNames,int32_t count,DtContextType context,DtWidthType width)894 DateFormatSymbols::setZodiacNames(const UnicodeString* zodiacNames, int32_t count,
895 DtContextType context, DtWidthType width)
896 {
897 if (context == FORMAT && width == ABBREVIATED) {
898 if (fShortZodiacNames) {
899 delete[] fShortZodiacNames;
900 }
901 fShortZodiacNames = newUnicodeStringArray(count);
902 uprv_arrayCopy(zodiacNames, fShortZodiacNames, count);
903 fShortZodiacNamesCount = count;
904 }
905 }
906
907 //------------------------------------------------------
908
909 void
setEras(const UnicodeString * erasArray,int32_t count)910 DateFormatSymbols::setEras(const UnicodeString* erasArray, int32_t count)
911 {
912 // delete the old list if we own it
913 if (fEras)
914 delete[] fEras;
915
916 // we always own the new list, which we create here (we duplicate rather
917 // than adopting the list passed in)
918 fEras = newUnicodeStringArray(count);
919 uprv_arrayCopy(erasArray,fEras, count);
920 fErasCount = count;
921 }
922
923 void
setEraNames(const UnicodeString * eraNamesArray,int32_t count)924 DateFormatSymbols::setEraNames(const UnicodeString* eraNamesArray, int32_t count)
925 {
926 // delete the old list if we own it
927 if (fEraNames)
928 delete[] fEraNames;
929
930 // we always own the new list, which we create here (we duplicate rather
931 // than adopting the list passed in)
932 fEraNames = newUnicodeStringArray(count);
933 uprv_arrayCopy(eraNamesArray,fEraNames, count);
934 fEraNamesCount = count;
935 }
936
937 void
setNarrowEras(const UnicodeString * narrowErasArray,int32_t count)938 DateFormatSymbols::setNarrowEras(const UnicodeString* narrowErasArray, int32_t count)
939 {
940 // delete the old list if we own it
941 if (fNarrowEras)
942 delete[] fNarrowEras;
943
944 // we always own the new list, which we create here (we duplicate rather
945 // than adopting the list passed in)
946 fNarrowEras = newUnicodeStringArray(count);
947 uprv_arrayCopy(narrowErasArray,fNarrowEras, count);
948 fNarrowErasCount = count;
949 }
950
951 void
setMonths(const UnicodeString * monthsArray,int32_t count)952 DateFormatSymbols::setMonths(const UnicodeString* monthsArray, int32_t count)
953 {
954 // delete the old list if we own it
955 if (fMonths)
956 delete[] fMonths;
957
958 // we always own the new list, which we create here (we duplicate rather
959 // than adopting the list passed in)
960 fMonths = newUnicodeStringArray(count);
961 uprv_arrayCopy( monthsArray,fMonths,count);
962 fMonthsCount = count;
963 }
964
965 void
setShortMonths(const UnicodeString * shortMonthsArray,int32_t count)966 DateFormatSymbols::setShortMonths(const UnicodeString* shortMonthsArray, int32_t count)
967 {
968 // delete the old list if we own it
969 if (fShortMonths)
970 delete[] fShortMonths;
971
972 // we always own the new list, which we create here (we duplicate rather
973 // than adopting the list passed in)
974 fShortMonths = newUnicodeStringArray(count);
975 uprv_arrayCopy(shortMonthsArray,fShortMonths, count);
976 fShortMonthsCount = count;
977 }
978
979 void
setMonths(const UnicodeString * monthsArray,int32_t count,DtContextType context,DtWidthType width)980 DateFormatSymbols::setMonths(const UnicodeString* monthsArray, int32_t count, DtContextType context, DtWidthType width)
981 {
982 // delete the old list if we own it
983 // we always own the new list, which we create here (we duplicate rather
984 // than adopting the list passed in)
985
986 switch (context) {
987 case FORMAT :
988 switch (width) {
989 case WIDE :
990 if (fMonths)
991 delete[] fMonths;
992 fMonths = newUnicodeStringArray(count);
993 uprv_arrayCopy( monthsArray,fMonths,count);
994 fMonthsCount = count;
995 break;
996 case ABBREVIATED :
997 if (fShortMonths)
998 delete[] fShortMonths;
999 fShortMonths = newUnicodeStringArray(count);
1000 uprv_arrayCopy( monthsArray,fShortMonths,count);
1001 fShortMonthsCount = count;
1002 break;
1003 case NARROW :
1004 if (fNarrowMonths)
1005 delete[] fNarrowMonths;
1006 fNarrowMonths = newUnicodeStringArray(count);
1007 uprv_arrayCopy( monthsArray,fNarrowMonths,count);
1008 fNarrowMonthsCount = count;
1009 break;
1010 default :
1011 break;
1012 }
1013 break;
1014 case STANDALONE :
1015 switch (width) {
1016 case WIDE :
1017 if (fStandaloneMonths)
1018 delete[] fStandaloneMonths;
1019 fStandaloneMonths = newUnicodeStringArray(count);
1020 uprv_arrayCopy( monthsArray,fStandaloneMonths,count);
1021 fStandaloneMonthsCount = count;
1022 break;
1023 case ABBREVIATED :
1024 if (fStandaloneShortMonths)
1025 delete[] fStandaloneShortMonths;
1026 fStandaloneShortMonths = newUnicodeStringArray(count);
1027 uprv_arrayCopy( monthsArray,fStandaloneShortMonths,count);
1028 fStandaloneShortMonthsCount = count;
1029 break;
1030 case NARROW :
1031 if (fStandaloneNarrowMonths)
1032 delete[] fStandaloneNarrowMonths;
1033 fStandaloneNarrowMonths = newUnicodeStringArray(count);
1034 uprv_arrayCopy( monthsArray,fStandaloneNarrowMonths,count);
1035 fStandaloneNarrowMonthsCount = count;
1036 break;
1037 default :
1038 break;
1039 }
1040 break;
1041 case DT_CONTEXT_COUNT :
1042 break;
1043 }
1044 }
1045
setWeekdays(const UnicodeString * weekdaysArray,int32_t count)1046 void DateFormatSymbols::setWeekdays(const UnicodeString* weekdaysArray, int32_t count)
1047 {
1048 // delete the old list if we own it
1049 if (fWeekdays)
1050 delete[] fWeekdays;
1051
1052 // we always own the new list, which we create here (we duplicate rather
1053 // than adopting the list passed in)
1054 fWeekdays = newUnicodeStringArray(count);
1055 uprv_arrayCopy(weekdaysArray,fWeekdays,count);
1056 fWeekdaysCount = count;
1057 }
1058
1059 void
setShortWeekdays(const UnicodeString * shortWeekdaysArray,int32_t count)1060 DateFormatSymbols::setShortWeekdays(const UnicodeString* shortWeekdaysArray, int32_t count)
1061 {
1062 // delete the old list if we own it
1063 if (fShortWeekdays)
1064 delete[] fShortWeekdays;
1065
1066 // we always own the new list, which we create here (we duplicate rather
1067 // than adopting the list passed in)
1068 fShortWeekdays = newUnicodeStringArray(count);
1069 uprv_arrayCopy(shortWeekdaysArray, fShortWeekdays, count);
1070 fShortWeekdaysCount = count;
1071 }
1072
1073 void
setWeekdays(const UnicodeString * weekdaysArray,int32_t count,DtContextType context,DtWidthType width)1074 DateFormatSymbols::setWeekdays(const UnicodeString* weekdaysArray, int32_t count, DtContextType context, DtWidthType width)
1075 {
1076 // delete the old list if we own it
1077 // we always own the new list, which we create here (we duplicate rather
1078 // than adopting the list passed in)
1079
1080 switch (context) {
1081 case FORMAT :
1082 switch (width) {
1083 case WIDE :
1084 if (fWeekdays)
1085 delete[] fWeekdays;
1086 fWeekdays = newUnicodeStringArray(count);
1087 uprv_arrayCopy(weekdaysArray, fWeekdays, count);
1088 fWeekdaysCount = count;
1089 break;
1090 case ABBREVIATED :
1091 if (fShortWeekdays)
1092 delete[] fShortWeekdays;
1093 fShortWeekdays = newUnicodeStringArray(count);
1094 uprv_arrayCopy(weekdaysArray, fShortWeekdays, count);
1095 fShortWeekdaysCount = count;
1096 break;
1097 case SHORT :
1098 if (fShorterWeekdays)
1099 delete[] fShorterWeekdays;
1100 fShorterWeekdays = newUnicodeStringArray(count);
1101 uprv_arrayCopy(weekdaysArray, fShorterWeekdays, count);
1102 fShorterWeekdaysCount = count;
1103 break;
1104 case NARROW :
1105 if (fNarrowWeekdays)
1106 delete[] fNarrowWeekdays;
1107 fNarrowWeekdays = newUnicodeStringArray(count);
1108 uprv_arrayCopy(weekdaysArray, fNarrowWeekdays, count);
1109 fNarrowWeekdaysCount = count;
1110 break;
1111 case DT_WIDTH_COUNT :
1112 break;
1113 }
1114 break;
1115 case STANDALONE :
1116 switch (width) {
1117 case WIDE :
1118 if (fStandaloneWeekdays)
1119 delete[] fStandaloneWeekdays;
1120 fStandaloneWeekdays = newUnicodeStringArray(count);
1121 uprv_arrayCopy(weekdaysArray, fStandaloneWeekdays, count);
1122 fStandaloneWeekdaysCount = count;
1123 break;
1124 case ABBREVIATED :
1125 if (fStandaloneShortWeekdays)
1126 delete[] fStandaloneShortWeekdays;
1127 fStandaloneShortWeekdays = newUnicodeStringArray(count);
1128 uprv_arrayCopy(weekdaysArray, fStandaloneShortWeekdays, count);
1129 fStandaloneShortWeekdaysCount = count;
1130 break;
1131 case SHORT :
1132 if (fStandaloneShorterWeekdays)
1133 delete[] fStandaloneShorterWeekdays;
1134 fStandaloneShorterWeekdays = newUnicodeStringArray(count);
1135 uprv_arrayCopy(weekdaysArray, fStandaloneShorterWeekdays, count);
1136 fStandaloneShorterWeekdaysCount = count;
1137 break;
1138 case NARROW :
1139 if (fStandaloneNarrowWeekdays)
1140 delete[] fStandaloneNarrowWeekdays;
1141 fStandaloneNarrowWeekdays = newUnicodeStringArray(count);
1142 uprv_arrayCopy(weekdaysArray, fStandaloneNarrowWeekdays, count);
1143 fStandaloneNarrowWeekdaysCount = count;
1144 break;
1145 case DT_WIDTH_COUNT :
1146 break;
1147 }
1148 break;
1149 case DT_CONTEXT_COUNT :
1150 break;
1151 }
1152 }
1153
1154 void
setQuarters(const UnicodeString * quartersArray,int32_t count,DtContextType context,DtWidthType width)1155 DateFormatSymbols::setQuarters(const UnicodeString* quartersArray, int32_t count, DtContextType context, DtWidthType width)
1156 {
1157 // delete the old list if we own it
1158 // we always own the new list, which we create here (we duplicate rather
1159 // than adopting the list passed in)
1160
1161 switch (context) {
1162 case FORMAT :
1163 switch (width) {
1164 case WIDE :
1165 if (fQuarters)
1166 delete[] fQuarters;
1167 fQuarters = newUnicodeStringArray(count);
1168 uprv_arrayCopy( quartersArray,fQuarters,count);
1169 fQuartersCount = count;
1170 break;
1171 case ABBREVIATED :
1172 if (fShortQuarters)
1173 delete[] fShortQuarters;
1174 fShortQuarters = newUnicodeStringArray(count);
1175 uprv_arrayCopy( quartersArray,fShortQuarters,count);
1176 fShortQuartersCount = count;
1177 break;
1178 case NARROW :
1179 /*
1180 if (fNarrowQuarters)
1181 delete[] fNarrowQuarters;
1182 fNarrowQuarters = newUnicodeStringArray(count);
1183 uprv_arrayCopy( quartersArray,fNarrowQuarters,count);
1184 fNarrowQuartersCount = count;
1185 */
1186 break;
1187 default :
1188 break;
1189 }
1190 break;
1191 case STANDALONE :
1192 switch (width) {
1193 case WIDE :
1194 if (fStandaloneQuarters)
1195 delete[] fStandaloneQuarters;
1196 fStandaloneQuarters = newUnicodeStringArray(count);
1197 uprv_arrayCopy( quartersArray,fStandaloneQuarters,count);
1198 fStandaloneQuartersCount = count;
1199 break;
1200 case ABBREVIATED :
1201 if (fStandaloneShortQuarters)
1202 delete[] fStandaloneShortQuarters;
1203 fStandaloneShortQuarters = newUnicodeStringArray(count);
1204 uprv_arrayCopy( quartersArray,fStandaloneShortQuarters,count);
1205 fStandaloneShortQuartersCount = count;
1206 break;
1207 case NARROW :
1208 /*
1209 if (fStandaloneNarrowQuarters)
1210 delete[] fStandaloneNarrowQuarters;
1211 fStandaloneNarrowQuarters = newUnicodeStringArray(count);
1212 uprv_arrayCopy( quartersArray,fStandaloneNarrowQuarters,count);
1213 fStandaloneNarrowQuartersCount = count;
1214 */
1215 break;
1216 default :
1217 break;
1218 }
1219 break;
1220 case DT_CONTEXT_COUNT :
1221 break;
1222 }
1223 }
1224
1225 void
setAmPmStrings(const UnicodeString * amPmsArray,int32_t count)1226 DateFormatSymbols::setAmPmStrings(const UnicodeString* amPmsArray, int32_t count)
1227 {
1228 // delete the old list if we own it
1229 if (fAmPms) delete[] fAmPms;
1230
1231 // we always own the new list, which we create here (we duplicate rather
1232 // than adopting the list passed in)
1233 fAmPms = newUnicodeStringArray(count);
1234 uprv_arrayCopy(amPmsArray,fAmPms,count);
1235 fAmPmsCount = count;
1236 }
1237
1238 void
setTimeSeparatorString(const UnicodeString & newTimeSeparator)1239 DateFormatSymbols::setTimeSeparatorString(const UnicodeString& newTimeSeparator)
1240 {
1241 fTimeSeparator = newTimeSeparator;
1242 }
1243
1244 const UnicodeString**
getZoneStrings(int32_t & rowCount,int32_t & columnCount) const1245 DateFormatSymbols::getZoneStrings(int32_t& rowCount, int32_t& columnCount) const
1246 {
1247 const UnicodeString **result = NULL;
1248
1249 umtx_lock(&LOCK);
1250 if (fZoneStrings == NULL) {
1251 if (fLocaleZoneStrings == NULL) {
1252 ((DateFormatSymbols*)this)->initZoneStringsArray();
1253 }
1254 result = (const UnicodeString**)fLocaleZoneStrings;
1255 } else {
1256 result = (const UnicodeString**)fZoneStrings;
1257 }
1258 rowCount = fZoneStringsRowCount;
1259 columnCount = fZoneStringsColCount;
1260 umtx_unlock(&LOCK);
1261
1262 return result;
1263 }
1264
1265 // For now, we include all zones
1266 #define ZONE_SET UCAL_ZONE_TYPE_ANY
1267
1268 // This code must be called within a synchronized block
1269 void
initZoneStringsArray(void)1270 DateFormatSymbols::initZoneStringsArray(void) {
1271 if (fZoneStrings != NULL || fLocaleZoneStrings != NULL) {
1272 return;
1273 }
1274
1275 UErrorCode status = U_ZERO_ERROR;
1276
1277 StringEnumeration *tzids = NULL;
1278 UnicodeString ** zarray = NULL;
1279 TimeZoneNames *tzNames = NULL;
1280 int32_t rows = 0;
1281
1282 static const UTimeZoneNameType TYPES[] = {
1283 UTZNM_LONG_STANDARD, UTZNM_SHORT_STANDARD,
1284 UTZNM_LONG_DAYLIGHT, UTZNM_SHORT_DAYLIGHT
1285 };
1286 static const int32_t NUM_TYPES = 4;
1287
1288 do { // dummy do-while
1289
1290 tzids = TimeZone::createTimeZoneIDEnumeration(ZONE_SET, NULL, NULL, status);
1291 rows = tzids->count(status);
1292 if (U_FAILURE(status)) {
1293 break;
1294 }
1295
1296 // Allocate array
1297 int32_t size = rows * sizeof(UnicodeString*);
1298 zarray = (UnicodeString**)uprv_malloc(size);
1299 if (zarray == NULL) {
1300 status = U_MEMORY_ALLOCATION_ERROR;
1301 break;
1302 }
1303 uprv_memset(zarray, 0, size);
1304
1305 tzNames = TimeZoneNames::createInstance(fZSFLocale, status);
1306 tzNames->loadAllDisplayNames(status);
1307 if (U_FAILURE(status)) { break; }
1308
1309 const UnicodeString *tzid;
1310 int32_t i = 0;
1311 UDate now = Calendar::getNow();
1312 UnicodeString tzDispName;
1313
1314 while ((tzid = tzids->snext(status))) {
1315 if (U_FAILURE(status)) {
1316 break;
1317 }
1318
1319 zarray[i] = new UnicodeString[5];
1320 if (zarray[i] == NULL) {
1321 status = U_MEMORY_ALLOCATION_ERROR;
1322 break;
1323 }
1324
1325 zarray[i][0].setTo(*tzid);
1326 tzNames->getDisplayNames(*tzid, TYPES, NUM_TYPES, now, zarray[i]+1, status);
1327 i++;
1328 }
1329
1330 } while (FALSE);
1331
1332 if (U_FAILURE(status)) {
1333 if (zarray) {
1334 for (int32_t i = 0; i < rows; i++) {
1335 if (zarray[i]) {
1336 delete[] zarray[i];
1337 }
1338 }
1339 uprv_free(zarray);
1340 zarray = NULL;
1341 }
1342 }
1343
1344 if (tzNames) {
1345 delete tzNames;
1346 }
1347 if (tzids) {
1348 delete tzids;
1349 }
1350
1351 fLocaleZoneStrings = zarray;
1352 fZoneStringsRowCount = rows;
1353 fZoneStringsColCount = 1 + NUM_TYPES;
1354 }
1355
1356 void
setZoneStrings(const UnicodeString * const * strings,int32_t rowCount,int32_t columnCount)1357 DateFormatSymbols::setZoneStrings(const UnicodeString* const *strings, int32_t rowCount, int32_t columnCount)
1358 {
1359 // since deleting a 2-d array is a pain in the butt, we offload that task to
1360 // a separate function
1361 disposeZoneStrings();
1362 // we always own the new list, which we create here (we duplicate rather
1363 // than adopting the list passed in)
1364 fZoneStringsRowCount = rowCount;
1365 fZoneStringsColCount = columnCount;
1366 createZoneStrings((const UnicodeString**)strings);
1367 }
1368
1369 //------------------------------------------------------
1370
1371 const UChar * U_EXPORT2
getPatternUChars(void)1372 DateFormatSymbols::getPatternUChars(void)
1373 {
1374 return gPatternChars;
1375 }
1376
1377 UDateFormatField U_EXPORT2
getPatternCharIndex(UChar c)1378 DateFormatSymbols::getPatternCharIndex(UChar c) {
1379 const UChar *p = u_strchr(gPatternChars, c);
1380 if (p == NULL) {
1381 return UDAT_FIELD_COUNT;
1382 } else {
1383 return static_cast<UDateFormatField>(p - gPatternChars);
1384 }
1385 }
1386
1387 static const uint64_t kNumericFieldsAlways =
1388 ((uint64_t)1 << UDAT_YEAR_FIELD) | // y
1389 ((uint64_t)1 << UDAT_DATE_FIELD) | // d
1390 ((uint64_t)1 << UDAT_HOUR_OF_DAY1_FIELD) | // k
1391 ((uint64_t)1 << UDAT_HOUR_OF_DAY0_FIELD) | // H
1392 ((uint64_t)1 << UDAT_MINUTE_FIELD) | // m
1393 ((uint64_t)1 << UDAT_SECOND_FIELD) | // s
1394 ((uint64_t)1 << UDAT_FRACTIONAL_SECOND_FIELD) | // S
1395 ((uint64_t)1 << UDAT_DAY_OF_YEAR_FIELD) | // D
1396 ((uint64_t)1 << UDAT_DAY_OF_WEEK_IN_MONTH_FIELD) | // F
1397 ((uint64_t)1 << UDAT_WEEK_OF_YEAR_FIELD) | // w
1398 ((uint64_t)1 << UDAT_WEEK_OF_MONTH_FIELD) | // W
1399 ((uint64_t)1 << UDAT_HOUR1_FIELD) | // h
1400 ((uint64_t)1 << UDAT_HOUR0_FIELD) | // K
1401 ((uint64_t)1 << UDAT_YEAR_WOY_FIELD) | // Y
1402 ((uint64_t)1 << UDAT_EXTENDED_YEAR_FIELD) | // u
1403 ((uint64_t)1 << UDAT_JULIAN_DAY_FIELD) | // g
1404 ((uint64_t)1 << UDAT_MILLISECONDS_IN_DAY_FIELD) | // A
1405 ((uint64_t)1 << UDAT_RELATED_YEAR_FIELD); // r
1406
1407 static const uint64_t kNumericFieldsForCount12 =
1408 ((uint64_t)1 << UDAT_MONTH_FIELD) | // M or MM
1409 ((uint64_t)1 << UDAT_DOW_LOCAL_FIELD) | // e or ee
1410 ((uint64_t)1 << UDAT_STANDALONE_DAY_FIELD) | // c or cc
1411 ((uint64_t)1 << UDAT_STANDALONE_MONTH_FIELD) | // L or LL
1412 ((uint64_t)1 << UDAT_QUARTER_FIELD) | // Q or QQ
1413 ((uint64_t)1 << UDAT_STANDALONE_QUARTER_FIELD); // q or qq
1414
1415 UBool U_EXPORT2
isNumericField(UDateFormatField f,int32_t count)1416 DateFormatSymbols::isNumericField(UDateFormatField f, int32_t count) {
1417 if (f == UDAT_FIELD_COUNT) {
1418 return FALSE;
1419 }
1420 uint64_t flag = ((uint64_t)1 << f);
1421 return ((kNumericFieldsAlways & flag) != 0 || ((kNumericFieldsForCount12 & flag) != 0 && count < 3));
1422 }
1423
1424 UBool U_EXPORT2
isNumericPatternChar(UChar c,int32_t count)1425 DateFormatSymbols::isNumericPatternChar(UChar c, int32_t count) {
1426 return isNumericField(getPatternCharIndex(c), count);
1427 }
1428
1429 //------------------------------------------------------
1430
1431 UnicodeString&
getLocalPatternChars(UnicodeString & result) const1432 DateFormatSymbols::getLocalPatternChars(UnicodeString& result) const
1433 {
1434 // fastCopyFrom() - see assignArray comments
1435 return result.fastCopyFrom(fLocalPatternChars);
1436 }
1437
1438 //------------------------------------------------------
1439
1440 void
setLocalPatternChars(const UnicodeString & newLocalPatternChars)1441 DateFormatSymbols::setLocalPatternChars(const UnicodeString& newLocalPatternChars)
1442 {
1443 fLocalPatternChars = newLocalPatternChars;
1444 }
1445
1446 //------------------------------------------------------
1447
1448 namespace {
1449
1450 // Constants declarations
1451 static const UChar kCalendarAliasPrefixUChar[] = {
1452 SOLIDUS, CAP_L, CAP_O, CAP_C, CAP_A, CAP_L, CAP_E, SOLIDUS,
1453 LOW_C, LOW_A, LOW_L, LOW_E, LOW_N, LOW_D, LOW_A, LOW_R, SOLIDUS
1454 };
1455 static const UChar kGregorianTagUChar[] = {
1456 LOW_G, LOW_R, LOW_E, LOW_G, LOW_O, LOW_R, LOW_I, LOW_A, LOW_N
1457 };
1458 static const UChar kVariantTagUChar[] = {
1459 PERCENT, LOW_V, LOW_A, LOW_R, LOW_I, LOW_A, LOW_N, LOW_T
1460 };
1461 static const UChar kLeapTagUChar[] = {
1462 LOW_L, LOW_E, LOW_A, LOW_P
1463 };
1464 static const UChar kCyclicNameSetsTagUChar[] = {
1465 LOW_C, LOW_Y, LOW_C, LOW_L, LOW_I, LOW_C, CAP_N, LOW_A, LOW_M, LOW_E, CAP_S, LOW_E, LOW_T, LOW_S
1466 };
1467 static const UChar kYearsTagUChar[] = {
1468 SOLIDUS, LOW_Y, LOW_E, LOW_A, LOW_R, LOW_S
1469 };
1470 static const UChar kZodiacsUChar[] = {
1471 SOLIDUS, LOW_Z, LOW_O, LOW_D, LOW_I, LOW_A, LOW_C, LOW_S
1472 };
1473 static const UChar kDayPartsTagUChar[] = {
1474 SOLIDUS, LOW_D, LOW_A, LOW_Y, CAP_P, LOW_A, LOW_R, LOW_T, LOW_S
1475 };
1476 static const UChar kFormatTagUChar[] = {
1477 SOLIDUS, LOW_F, LOW_O, LOW_R, LOW_M, LOW_A, LOW_T
1478 };
1479 static const UChar kAbbrTagUChar[] = {
1480 SOLIDUS, LOW_A, LOW_B, LOW_B, LOW_R, LOW_E, LOW_V, LOW_I, LOW_A, LOW_T, LOW_E, LOW_D
1481 };
1482
1483 // ResourceSink to enumerate all calendar resources
1484 struct CalendarDataSink : public ResourceSink {
1485
1486 // Enum which specifies the type of alias received, or no alias
1487 enum AliasType {
1488 SAME_CALENDAR,
1489 DIFFERENT_CALENDAR,
1490 GREGORIAN,
1491 NONE
1492 };
1493
1494 // Data structures to store resources from the current resource bundle
1495 Hashtable arrays;
1496 Hashtable arraySizes;
1497 Hashtable maps;
1498 /**
1499 * Whenever there are aliases, the same object will be added twice to 'map'.
1500 * To avoid double deletion, 'maps' won't take ownership of the objects. Instead,
1501 * 'mapRefs' will own them and will delete them when CalendarDataSink is deleted.
1502 */
1503 UVector mapRefs;
1504
1505 // Paths and the aliases they point to
1506 UVector aliasPathPairs;
1507
1508 // Current and next calendar resource table which should be loaded
1509 UnicodeString currentCalendarType;
1510 UnicodeString nextCalendarType;
1511
1512 // Resources to visit when enumerating fallback calendars
1513 LocalPointer<UVector> resourcesToVisit;
1514
1515 // Alias' relative path populated whenever an alias is read
1516 UnicodeString aliasRelativePath;
1517
1518 // Initializes CalendarDataSink with default values
CalendarDataSink__anone09cefdf0111::CalendarDataSink1519 CalendarDataSink(UErrorCode& status)
1520 : arrays(FALSE, status), arraySizes(FALSE, status), maps(FALSE, status),
1521 mapRefs(deleteHashtable, NULL, 10, status),
1522 aliasPathPairs(uprv_deleteUObject, uhash_compareUnicodeString, status),
1523 currentCalendarType(), nextCalendarType(),
1524 resourcesToVisit(NULL), aliasRelativePath() {
1525 if (U_FAILURE(status)) { return; }
1526 }
1527 virtual ~CalendarDataSink();
1528
1529 // Configure the CalendarSink to visit all the resources
visitAllResources__anone09cefdf0111::CalendarDataSink1530 void visitAllResources() {
1531 resourcesToVisit.adoptInstead(NULL);
1532 }
1533
1534 // Actions to be done before enumerating
preEnumerate__anone09cefdf0111::CalendarDataSink1535 void preEnumerate(const UnicodeString &calendarType) {
1536 currentCalendarType = calendarType;
1537 nextCalendarType.setToBogus();
1538 aliasPathPairs.removeAllElements();
1539 }
1540
put__anone09cefdf0111::CalendarDataSink1541 virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) {
1542 if (U_FAILURE(errorCode)) { return; }
1543 U_ASSERT(!currentCalendarType.isEmpty());
1544
1545 // Stores the resources to visit on the next calendar.
1546 LocalPointer<UVector> resourcesToVisitNext(NULL);
1547 ResourceTable calendarData = value.getTable(errorCode);
1548 if (U_FAILURE(errorCode)) { return; }
1549
1550 // Enumerate all resources for this calendar
1551 for (int i = 0; calendarData.getKeyAndValue(i, key, value); i++) {
1552 UnicodeString keyUString(key, -1, US_INV);
1553
1554 // == Handle aliases ==
1555 AliasType aliasType = processAliasFromValue(keyUString, value, errorCode);
1556 if (U_FAILURE(errorCode)) { return; }
1557 if (aliasType == GREGORIAN) {
1558 // Ignore aliases to the gregorian calendar, all of its resources will be loaded anyway.
1559 continue;
1560
1561 } else if (aliasType == DIFFERENT_CALENDAR) {
1562 // Whenever an alias to the next calendar (except gregorian) is encountered, register the
1563 // calendar type it's pointing to
1564 if (resourcesToVisitNext.isNull()) {
1565 resourcesToVisitNext
1566 .adoptInsteadAndCheckErrorCode(new UVector(uprv_deleteUObject, uhash_compareUnicodeString, errorCode),
1567 errorCode);
1568 if (U_FAILURE(errorCode)) { return; }
1569 }
1570 LocalPointer<UnicodeString> aliasRelativePathCopy(new UnicodeString(aliasRelativePath), errorCode);
1571 resourcesToVisitNext->addElement(aliasRelativePathCopy.getAlias(), errorCode);
1572 if (U_FAILURE(errorCode)) { return; }
1573 // Only release ownership after resourcesToVisitNext takes it (no error happened):
1574 aliasRelativePathCopy.orphan();
1575 continue;
1576
1577 } else if (aliasType == SAME_CALENDAR) {
1578 // Register same-calendar alias
1579 if (arrays.get(aliasRelativePath) == NULL && maps.get(aliasRelativePath) == NULL) {
1580 LocalPointer<UnicodeString> aliasRelativePathCopy(new UnicodeString(aliasRelativePath), errorCode);
1581 aliasPathPairs.addElement(aliasRelativePathCopy.getAlias(), errorCode);
1582 if (U_FAILURE(errorCode)) { return; }
1583 // Only release ownership after aliasPathPairs takes it (no error happened):
1584 aliasRelativePathCopy.orphan();
1585 LocalPointer<UnicodeString> keyUStringCopy(new UnicodeString(keyUString), errorCode);
1586 aliasPathPairs.addElement(keyUStringCopy.getAlias(), errorCode);
1587 if (U_FAILURE(errorCode)) { return; }
1588 // Only release ownership after aliasPathPairs takes it (no error happened):
1589 keyUStringCopy.orphan();
1590 }
1591 continue;
1592 }
1593
1594 // Only visit the resources that were referenced by an alias on the previous calendar
1595 // (AmPmMarkersAbbr is an exception).
1596 if (!resourcesToVisit.isNull() && !resourcesToVisit->isEmpty() && !resourcesToVisit->contains(&keyUString)
1597 && uprv_strcmp(key, gAmPmMarkersAbbrTag) != 0) { continue; }
1598
1599 // == Handle data ==
1600 if (uprv_strcmp(key, gAmPmMarkersTag) == 0
1601 || uprv_strcmp(key, gAmPmMarkersAbbrTag) == 0
1602 || uprv_strcmp(key, gAmPmMarkersNarrowTag) == 0) {
1603 if (arrays.get(keyUString) == NULL) {
1604 ResourceArray resourceArray = value.getArray(errorCode);
1605 int32_t arraySize = resourceArray.getSize();
1606 LocalArray<UnicodeString> stringArray(new UnicodeString[arraySize], errorCode);
1607 value.getStringArray(stringArray.getAlias(), arraySize, errorCode);
1608 arrays.put(keyUString, stringArray.orphan(), errorCode);
1609 arraySizes.puti(keyUString, arraySize, errorCode);
1610 if (U_FAILURE(errorCode)) { return; }
1611 }
1612 } else if (uprv_strcmp(key, gErasTag) == 0
1613 || uprv_strcmp(key, gDayNamesTag) == 0
1614 || uprv_strcmp(key, gMonthNamesTag) == 0
1615 || uprv_strcmp(key, gQuartersTag) == 0
1616 || uprv_strcmp(key, gDayPeriodTag) == 0
1617 || uprv_strcmp(key, gMonthPatternsTag) == 0
1618 || uprv_strcmp(key, gCyclicNameSetsTag) == 0) {
1619 processResource(keyUString, key, value, errorCode);
1620 }
1621 }
1622
1623 // Apply same-calendar aliases
1624 UBool modified;
1625 do {
1626 modified = false;
1627 for (int32_t i = 0; i < aliasPathPairs.size();) {
1628 UBool mod = false;
1629 UnicodeString *alias = (UnicodeString*)aliasPathPairs[i];
1630 UnicodeString *aliasArray;
1631 Hashtable *aliasMap;
1632 if ((aliasArray = (UnicodeString*)arrays.get(*alias)) != NULL) {
1633 // Clone the array
1634 int32_t aliasArraySize = arraySizes.geti(*alias);
1635 LocalArray<UnicodeString> aliasArrayCopy(new UnicodeString[aliasArraySize], errorCode);
1636 if (U_FAILURE(errorCode)) { return; }
1637 uprv_arrayCopy(aliasArray, aliasArrayCopy.getAlias(), aliasArraySize);
1638 // Put the array on the 'arrays' map
1639 UnicodeString *path = (UnicodeString*)aliasPathPairs[i + 1];
1640 arrays.put(*path, aliasArrayCopy.orphan(), errorCode);
1641 arraySizes.puti(*path, aliasArraySize, errorCode);
1642 if (U_FAILURE(errorCode)) { return; }
1643 mod = true;
1644 } else if ((aliasMap = (Hashtable*)maps.get(*alias)) != NULL) {
1645 UnicodeString *path = (UnicodeString*)aliasPathPairs[i + 1];
1646 maps.put(*path, aliasMap, errorCode);
1647 if (U_FAILURE(errorCode)) { return; }
1648 mod = true;
1649 }
1650 if (mod) {
1651 aliasPathPairs.removeElementAt(i + 1);
1652 aliasPathPairs.removeElementAt(i);
1653 modified = true;
1654 } else {
1655 i += 2;
1656 }
1657 }
1658 } while (modified && !aliasPathPairs.isEmpty());
1659
1660 // Set the resources to visit on the next calendar
1661 if (!resourcesToVisitNext.isNull()) {
1662 resourcesToVisit.moveFrom(resourcesToVisitNext);
1663 }
1664 }
1665
1666 // Process the nested resource bundle tables
processResource__anone09cefdf0111::CalendarDataSink1667 void processResource(UnicodeString &path, const char *key, ResourceValue &value, UErrorCode &errorCode) {
1668 if (U_FAILURE(errorCode)) return;
1669
1670 ResourceTable table = value.getTable(errorCode);
1671 if (U_FAILURE(errorCode)) return;
1672 Hashtable* stringMap = NULL;
1673
1674 // Iterate over all the elements of the table and add them to the map
1675 for (int i = 0; table.getKeyAndValue(i, key, value); i++) {
1676 UnicodeString keyUString(key, -1, US_INV);
1677
1678 // Ignore '%variant' keys
1679 if (keyUString.endsWith(kVariantTagUChar, UPRV_LENGTHOF(kVariantTagUChar))) {
1680 continue;
1681 }
1682
1683 // == Handle String elements ==
1684 if (value.getType() == URES_STRING) {
1685 // We are on a leaf, store the map elements into the stringMap
1686 if (i == 0) {
1687 LocalPointer<Hashtable> stringMapPtr(new Hashtable(FALSE, errorCode), errorCode);
1688 stringMap = stringMapPtr.getAlias();
1689 maps.put(path, stringMap, errorCode);
1690 // mapRefs will take ownership of 'stringMap':
1691 mapRefs.addElement(stringMap, errorCode);
1692 if (U_FAILURE(errorCode)) { return; }
1693 // Only release ownership after mapRefs takes it (no error happened):
1694 stringMapPtr.orphan();
1695 stringMap->setValueDeleter(uprv_deleteUObject);
1696 }
1697 U_ASSERT(stringMap != NULL);
1698 int32_t valueStringSize;
1699 const UChar *valueString = value.getString(valueStringSize, errorCode);
1700 if (U_FAILURE(errorCode)) { return; }
1701 LocalPointer<UnicodeString> valueUString(new UnicodeString(TRUE, valueString, valueStringSize), errorCode);
1702 stringMap->put(keyUString, valueUString.orphan(), errorCode);
1703 if (U_FAILURE(errorCode)) { return; }
1704 continue;
1705 }
1706 U_ASSERT(stringMap == NULL);
1707
1708 // Store the current path's length and append the current key to the path.
1709 int32_t pathLength = path.length();
1710 path.append(SOLIDUS).append(keyUString);
1711
1712 // In cyclicNameSets ignore everything but years/format/abbreviated
1713 // and zodiacs/format/abbreviated
1714 if (path.startsWith(kCyclicNameSetsTagUChar, UPRV_LENGTHOF(kCyclicNameSetsTagUChar))) {
1715 UBool skip = TRUE;
1716 int32_t startIndex = UPRV_LENGTHOF(kCyclicNameSetsTagUChar);
1717 int32_t length = 0;
1718 if (startIndex == path.length()
1719 || path.compare(startIndex, (length = UPRV_LENGTHOF(kZodiacsUChar)), kZodiacsUChar, 0, UPRV_LENGTHOF(kZodiacsUChar)) == 0
1720 || path.compare(startIndex, (length = UPRV_LENGTHOF(kYearsTagUChar)), kYearsTagUChar, 0, UPRV_LENGTHOF(kYearsTagUChar)) == 0
1721 || path.compare(startIndex, (length = UPRV_LENGTHOF(kDayPartsTagUChar)), kDayPartsTagUChar, 0, UPRV_LENGTHOF(kDayPartsTagUChar)) == 0) {
1722 startIndex += length;
1723 length = 0;
1724 if (startIndex == path.length()
1725 || path.compare(startIndex, (length = UPRV_LENGTHOF(kFormatTagUChar)), kFormatTagUChar, 0, UPRV_LENGTHOF(kFormatTagUChar)) == 0) {
1726 startIndex += length;
1727 length = 0;
1728 if (startIndex == path.length()
1729 || path.compare(startIndex, (length = UPRV_LENGTHOF(kAbbrTagUChar)), kAbbrTagUChar, 0, UPRV_LENGTHOF(kAbbrTagUChar)) == 0) {
1730 skip = FALSE;
1731 }
1732 }
1733 }
1734 if (skip) {
1735 // Drop the latest key on the path and continue
1736 path.retainBetween(0, pathLength);
1737 continue;
1738 }
1739 }
1740
1741 // == Handle aliases ==
1742 if (arrays.get(path) != NULL || maps.get(path) != NULL) {
1743 // Drop the latest key on the path and continue
1744 path.retainBetween(0, pathLength);
1745 continue;
1746 }
1747
1748 AliasType aliasType = processAliasFromValue(path, value, errorCode);
1749 if (U_FAILURE(errorCode)) { return; }
1750 if (aliasType == SAME_CALENDAR) {
1751 // Store the alias path and the current path on aliasPathPairs
1752 LocalPointer<UnicodeString> aliasRelativePathCopy(new UnicodeString(aliasRelativePath), errorCode);
1753 aliasPathPairs.addElement(aliasRelativePathCopy.getAlias(), errorCode);
1754 if (U_FAILURE(errorCode)) { return; }
1755 // Only release ownership after aliasPathPairs takes it (no error happened):
1756 aliasRelativePathCopy.orphan();
1757 LocalPointer<UnicodeString> pathCopy(new UnicodeString(path), errorCode);
1758 aliasPathPairs.addElement(pathCopy.getAlias(), errorCode);
1759 if (U_FAILURE(errorCode)) { return; }
1760 // Only release ownership after aliasPathPairs takes it (no error happened):
1761 pathCopy.orphan();
1762
1763 // Drop the latest key on the path and continue
1764 path.retainBetween(0, pathLength);
1765 continue;
1766 }
1767 U_ASSERT(aliasType == NONE);
1768
1769 // == Handle data ==
1770 if (value.getType() == URES_ARRAY) {
1771 // We are on a leaf, store the array
1772 ResourceArray rDataArray = value.getArray(errorCode);
1773 int32_t dataArraySize = rDataArray.getSize();
1774 LocalArray<UnicodeString> dataArray(new UnicodeString[dataArraySize], errorCode);
1775 value.getStringArray(dataArray.getAlias(), dataArraySize, errorCode);
1776 arrays.put(path, dataArray.orphan(), errorCode);
1777 arraySizes.puti(path, dataArraySize, errorCode);
1778 if (U_FAILURE(errorCode)) { return; }
1779 } else if (value.getType() == URES_TABLE) {
1780 // We are not on a leaf, recursively process the subtable.
1781 processResource(path, key, value, errorCode);
1782 if (U_FAILURE(errorCode)) { return; }
1783 }
1784
1785 // Drop the latest key on the path
1786 path.retainBetween(0, pathLength);
1787 }
1788 }
1789
1790 // Populates an AliasIdentifier with the alias information contained on the UResource.Value.
processAliasFromValue__anone09cefdf0111::CalendarDataSink1791 AliasType processAliasFromValue(UnicodeString ¤tRelativePath, ResourceValue &value,
1792 UErrorCode &errorCode) {
1793 if (U_FAILURE(errorCode)) { return NONE; }
1794
1795 if (value.getType() == URES_ALIAS) {
1796 int32_t aliasPathSize;
1797 const UChar* aliasPathUChar = value.getAliasString(aliasPathSize, errorCode);
1798 if (U_FAILURE(errorCode)) { return NONE; }
1799 UnicodeString aliasPath(aliasPathUChar, aliasPathSize);
1800 const int32_t aliasPrefixLength = UPRV_LENGTHOF(kCalendarAliasPrefixUChar);
1801 if (aliasPath.startsWith(kCalendarAliasPrefixUChar, aliasPrefixLength)
1802 && aliasPath.length() > aliasPrefixLength) {
1803 int32_t typeLimit = aliasPath.indexOf(SOLIDUS, aliasPrefixLength);
1804 if (typeLimit > aliasPrefixLength) {
1805 const UnicodeString aliasCalendarType =
1806 aliasPath.tempSubStringBetween(aliasPrefixLength, typeLimit);
1807 aliasRelativePath.setTo(aliasPath, typeLimit + 1, aliasPath.length());
1808
1809 if (currentCalendarType == aliasCalendarType
1810 && currentRelativePath != aliasRelativePath) {
1811 // If we have an alias to the same calendar, the path to the resource must be different
1812 return SAME_CALENDAR;
1813
1814 } else if (currentCalendarType != aliasCalendarType
1815 && currentRelativePath == aliasRelativePath) {
1816 // If we have an alias to a different calendar, the path to the resource must be the same
1817 if (aliasCalendarType.compare(kGregorianTagUChar, UPRV_LENGTHOF(kGregorianTagUChar)) == 0) {
1818 return GREGORIAN;
1819 } else if (nextCalendarType.isBogus()) {
1820 nextCalendarType = aliasCalendarType;
1821 return DIFFERENT_CALENDAR;
1822 } else if (nextCalendarType == aliasCalendarType) {
1823 return DIFFERENT_CALENDAR;
1824 }
1825 }
1826 }
1827 }
1828 errorCode = U_INTERNAL_PROGRAM_ERROR;
1829 return NONE;
1830 }
1831 return NONE;
1832 }
1833
1834 // Deleter function to be used by 'arrays'
deleteUnicodeStringArray__anone09cefdf0111::CalendarDataSink1835 static void U_CALLCONV deleteUnicodeStringArray(void *uArray) {
1836 delete[] static_cast<UnicodeString *>(uArray);
1837 }
1838
1839 // Deleter function to be used by 'maps'
deleteHashtable__anone09cefdf0111::CalendarDataSink1840 static void U_CALLCONV deleteHashtable(void *table) {
1841 delete static_cast<Hashtable *>(table);
1842 }
1843 };
1844 // Virtual destructors have to be defined out of line
~CalendarDataSink()1845 CalendarDataSink::~CalendarDataSink() {
1846 arrays.setValueDeleter(deleteUnicodeStringArray);
1847 }
1848 }
1849
1850 //------------------------------------------------------
1851
1852 static void
initField(UnicodeString ** field,int32_t & length,const UChar * data,LastResortSize numStr,LastResortSize strLen,UErrorCode & status)1853 initField(UnicodeString **field, int32_t& length, const UChar *data, LastResortSize numStr, LastResortSize strLen, UErrorCode &status) {
1854 if (U_SUCCESS(status)) {
1855 length = numStr;
1856 *field = newUnicodeStringArray((size_t)numStr);
1857 if (*field) {
1858 for(int32_t i = 0; i<length; i++) {
1859 // readonly aliases - all "data" strings are constant
1860 // -1 as length for variable-length strings (gLastResortDayNames[0] is empty)
1861 (*(field)+i)->setTo(TRUE, data+(i*((int32_t)strLen)), -1);
1862 }
1863 }
1864 else {
1865 length = 0;
1866 status = U_MEMORY_ALLOCATION_ERROR;
1867 }
1868 }
1869 }
1870
1871 static void
initField(UnicodeString ** field,int32_t & length,CalendarDataSink & sink,CharString & key,UErrorCode & status)1872 initField(UnicodeString **field, int32_t& length, CalendarDataSink &sink, CharString &key, UErrorCode &status) {
1873 if (U_SUCCESS(status)) {
1874 UnicodeString keyUString(key.data(), -1, US_INV);
1875 UnicodeString* array = static_cast<UnicodeString*>(sink.arrays.get(keyUString));
1876
1877 if (array != NULL) {
1878 length = sink.arraySizes.geti(keyUString);
1879 *field = array;
1880 // DateFormatSymbols takes ownership of the array:
1881 sink.arrays.remove(keyUString);
1882 } else {
1883 length = 0;
1884 status = U_MISSING_RESOURCE_ERROR;
1885 }
1886 }
1887 }
1888
1889 static void
initField(UnicodeString ** field,int32_t & length,CalendarDataSink & sink,CharString & key,int32_t arrayOffset,UErrorCode & status)1890 initField(UnicodeString **field, int32_t& length, CalendarDataSink &sink, CharString &key, int32_t arrayOffset, UErrorCode &status) {
1891 if (U_SUCCESS(status)) {
1892 UnicodeString keyUString(key.data(), -1, US_INV);
1893 UnicodeString* array = static_cast<UnicodeString*>(sink.arrays.get(keyUString));
1894
1895 if (array != NULL) {
1896 int32_t arrayLength = sink.arraySizes.geti(keyUString);
1897 length = arrayLength + arrayOffset;
1898 *field = new UnicodeString[length];
1899 if (*field == NULL) {
1900 status = U_MEMORY_ALLOCATION_ERROR;
1901 return;
1902 }
1903 uprv_arrayCopy(array, 0, *field, arrayOffset, arrayLength);
1904 } else {
1905 length = 0;
1906 status = U_MISSING_RESOURCE_ERROR;
1907 }
1908 }
1909 }
1910
1911 static void
initLeapMonthPattern(UnicodeString * field,int32_t index,CalendarDataSink & sink,CharString & path,UErrorCode & status)1912 initLeapMonthPattern(UnicodeString *field, int32_t index, CalendarDataSink &sink, CharString &path, UErrorCode &status) {
1913 field[index].remove();
1914 if (U_SUCCESS(status)) {
1915 UnicodeString pathUString(path.data(), -1, US_INV);
1916 Hashtable *leapMonthTable = static_cast<Hashtable*>(sink.maps.get(pathUString));
1917 if (leapMonthTable != NULL) {
1918 UnicodeString leapLabel(FALSE, kLeapTagUChar, UPRV_LENGTHOF(kLeapTagUChar));
1919 UnicodeString *leapMonthPattern = static_cast<UnicodeString*>(leapMonthTable->get(leapLabel));
1920 if (leapMonthPattern != NULL) {
1921 field[index].fastCopyFrom(*leapMonthPattern);
1922 } else {
1923 field[index].setToBogus();
1924 }
1925 return;
1926 }
1927 status = U_MISSING_RESOURCE_ERROR;
1928 }
1929 }
1930
1931 static CharString
buildResourcePath(CharString & path,const char * segment1,UErrorCode & errorCode)1932 &buildResourcePath(CharString &path, const char* segment1, UErrorCode &errorCode) {
1933 return path.clear().append(segment1, -1, errorCode);
1934 }
1935
1936 static CharString
buildResourcePath(CharString & path,const char * segment1,const char * segment2,UErrorCode & errorCode)1937 &buildResourcePath(CharString &path, const char* segment1, const char* segment2,
1938 UErrorCode &errorCode) {
1939 return buildResourcePath(path, segment1, errorCode).append('/', errorCode)
1940 .append(segment2, -1, errorCode);
1941 }
1942
1943 static CharString
buildResourcePath(CharString & path,const char * segment1,const char * segment2,const char * segment3,UErrorCode & errorCode)1944 &buildResourcePath(CharString &path, const char* segment1, const char* segment2,
1945 const char* segment3, UErrorCode &errorCode) {
1946 return buildResourcePath(path, segment1, segment2, errorCode).append('/', errorCode)
1947 .append(segment3, -1, errorCode);
1948 }
1949
1950 static CharString
buildResourcePath(CharString & path,const char * segment1,const char * segment2,const char * segment3,const char * segment4,UErrorCode & errorCode)1951 &buildResourcePath(CharString &path, const char* segment1, const char* segment2,
1952 const char* segment3, const char* segment4, UErrorCode &errorCode) {
1953 return buildResourcePath(path, segment1, segment2, segment3, errorCode).append('/', errorCode)
1954 .append(segment4, -1, errorCode);
1955 }
1956
1957 typedef struct {
1958 const char * usageTypeName;
1959 DateFormatSymbols::ECapitalizationContextUsageType usageTypeEnumValue;
1960 } ContextUsageTypeNameToEnumValue;
1961
1962 static const ContextUsageTypeNameToEnumValue contextUsageTypeMap[] = {
1963 // Entries must be sorted by usageTypeName; entry with NULL name terminates list.
1964 { "day-format-except-narrow", DateFormatSymbols::kCapContextUsageDayFormat },
1965 { "day-narrow", DateFormatSymbols::kCapContextUsageDayNarrow },
1966 { "day-standalone-except-narrow", DateFormatSymbols::kCapContextUsageDayStandalone },
1967 { "era-abbr", DateFormatSymbols::kCapContextUsageEraAbbrev },
1968 { "era-name", DateFormatSymbols::kCapContextUsageEraWide },
1969 { "era-narrow", DateFormatSymbols::kCapContextUsageEraNarrow },
1970 { "metazone-long", DateFormatSymbols::kCapContextUsageMetazoneLong },
1971 { "metazone-short", DateFormatSymbols::kCapContextUsageMetazoneShort },
1972 { "month-format-except-narrow", DateFormatSymbols::kCapContextUsageMonthFormat },
1973 { "month-narrow", DateFormatSymbols::kCapContextUsageMonthNarrow },
1974 { "month-standalone-except-narrow", DateFormatSymbols::kCapContextUsageMonthStandalone },
1975 { "zone-long", DateFormatSymbols::kCapContextUsageZoneLong },
1976 { "zone-short", DateFormatSymbols::kCapContextUsageZoneShort },
1977 { NULL, (DateFormatSymbols::ECapitalizationContextUsageType)0 },
1978 };
1979
1980 // Resource keys to look up localized strings for day periods.
1981 // The first one must be midnight and the second must be noon, so that their indices coincide
1982 // with the am/pm field. Formatting and parsing code for day periods relies on this coincidence.
1983 static const char *dayPeriodKeys[] = {"midnight", "noon",
1984 "morning1", "afternoon1", "evening1", "night1",
1985 "morning2", "afternoon2", "evening2", "night2"};
1986
loadDayPeriodStrings(CalendarDataSink & sink,CharString & path,int32_t & stringCount,UErrorCode & status)1987 UnicodeString* loadDayPeriodStrings(CalendarDataSink &sink, CharString &path,
1988 int32_t &stringCount, UErrorCode &status) {
1989 if (U_FAILURE(status)) { return NULL; }
1990
1991 UnicodeString pathUString(path.data(), -1, US_INV);
1992 Hashtable* map = static_cast<Hashtable*>(sink.maps.get(pathUString));
1993
1994 stringCount = UPRV_LENGTHOF(dayPeriodKeys);
1995 UnicodeString *strings = new UnicodeString[stringCount];
1996 if (strings == NULL) {
1997 status = U_MEMORY_ALLOCATION_ERROR;
1998 return NULL;
1999 }
2000
2001 if (map != NULL) {
2002 for (int32_t i = 0; i < stringCount; ++i) {
2003 UnicodeString dayPeriodKey(dayPeriodKeys[i], -1, US_INV);
2004 UnicodeString *dayPeriod = static_cast<UnicodeString*>(map->get(dayPeriodKey));
2005 if (dayPeriod != NULL) {
2006 strings[i].fastCopyFrom(*dayPeriod);
2007 } else {
2008 strings[i].setToBogus();
2009 }
2010 }
2011 } else {
2012 for (int32_t i = 0; i < stringCount; i++) {
2013 strings[i].setToBogus();
2014 }
2015 }
2016 return strings;
2017 }
2018
2019
2020 void
initializeData(const Locale & locale,const char * type,UErrorCode & status,UBool useLastResortData)2021 DateFormatSymbols::initializeData(const Locale& locale, const char *type, UErrorCode& status, UBool useLastResortData)
2022 {
2023 int32_t len = 0;
2024 /* In case something goes wrong, initialize all of the data to NULL. */
2025 fEras = NULL;
2026 fErasCount = 0;
2027 fEraNames = NULL;
2028 fEraNamesCount = 0;
2029 fNarrowEras = NULL;
2030 fNarrowErasCount = 0;
2031 fMonths = NULL;
2032 fMonthsCount=0;
2033 fShortMonths = NULL;
2034 fShortMonthsCount=0;
2035 fNarrowMonths = NULL;
2036 fNarrowMonthsCount=0;
2037 fStandaloneMonths = NULL;
2038 fStandaloneMonthsCount=0;
2039 fStandaloneShortMonths = NULL;
2040 fStandaloneShortMonthsCount=0;
2041 fStandaloneNarrowMonths = NULL;
2042 fStandaloneNarrowMonthsCount=0;
2043 fWeekdays = NULL;
2044 fWeekdaysCount=0;
2045 fShortWeekdays = NULL;
2046 fShortWeekdaysCount=0;
2047 fShorterWeekdays = NULL;
2048 fShorterWeekdaysCount=0;
2049 fNarrowWeekdays = NULL;
2050 fNarrowWeekdaysCount=0;
2051 fStandaloneWeekdays = NULL;
2052 fStandaloneWeekdaysCount=0;
2053 fStandaloneShortWeekdays = NULL;
2054 fStandaloneShortWeekdaysCount=0;
2055 fStandaloneShorterWeekdays = NULL;
2056 fStandaloneShorterWeekdaysCount=0;
2057 fStandaloneNarrowWeekdays = NULL;
2058 fStandaloneNarrowWeekdaysCount=0;
2059 fAmPms = NULL;
2060 fAmPmsCount=0;
2061 fNarrowAmPms = NULL;
2062 fNarrowAmPmsCount=0;
2063 fTimeSeparator.setToBogus();
2064 fQuarters = NULL;
2065 fQuartersCount = 0;
2066 fShortQuarters = NULL;
2067 fShortQuartersCount = 0;
2068 fStandaloneQuarters = NULL;
2069 fStandaloneQuartersCount = 0;
2070 fStandaloneShortQuarters = NULL;
2071 fStandaloneShortQuartersCount = 0;
2072 fLeapMonthPatterns = NULL;
2073 fLeapMonthPatternsCount = 0;
2074 fShortYearNames = NULL;
2075 fShortYearNamesCount = 0;
2076 fShortZodiacNames = NULL;
2077 fShortZodiacNamesCount = 0;
2078 fZoneStringsRowCount = 0;
2079 fZoneStringsColCount = 0;
2080 fZoneStrings = NULL;
2081 fLocaleZoneStrings = NULL;
2082 fAbbreviatedDayPeriods = NULL;
2083 fAbbreviatedDayPeriodsCount = 0;
2084 fWideDayPeriods = NULL;
2085 fWideDayPeriodsCount = 0;
2086 fNarrowDayPeriods = NULL;
2087 fNarrowDayPeriodsCount = 0;
2088 fStandaloneAbbreviatedDayPeriods = NULL;
2089 fStandaloneAbbreviatedDayPeriodsCount = 0;
2090 fStandaloneWideDayPeriods = NULL;
2091 fStandaloneWideDayPeriodsCount = 0;
2092 fStandaloneNarrowDayPeriods = NULL;
2093 fStandaloneNarrowDayPeriodsCount = 0;
2094 uprv_memset(fCapitalization, 0, sizeof(fCapitalization));
2095
2096 // We need to preserve the requested locale for
2097 // lazy ZoneStringFormat instantiation. ZoneStringFormat
2098 // is region sensitive, thus, bundle locale bundle's locale
2099 // is not sufficient.
2100 fZSFLocale = locale;
2101
2102 if (U_FAILURE(status)) return;
2103
2104 // Create a CalendarDataSink to process this data and the resouce bundles
2105 CalendarDataSink calendarSink(status);
2106 UResourceBundle *rb = ures_open(NULL, locale.getBaseName(), &status);
2107 UResourceBundle *cb = ures_getByKey(rb, gCalendarTag, NULL, &status);
2108
2109 if (U_FAILURE(status)) return;
2110
2111 // Iterate over the resource bundle data following the fallbacks through different calendar types
2112 UnicodeString calendarType((type != NULL && *type != '\0')? type : gGregorianTag, -1, US_INV);
2113 while (!calendarType.isBogus()) {
2114 CharString calendarTypeBuffer;
2115 calendarTypeBuffer.appendInvariantChars(calendarType, status);
2116 if (U_FAILURE(status)) { return; }
2117 const char *calendarTypeCArray = calendarTypeBuffer.data();
2118
2119 // Enumerate this calendar type. If the calendar is not found fallback to gregorian
2120 UErrorCode oldStatus = status;
2121 UResourceBundle *ctb = ures_getByKeyWithFallback(cb, calendarTypeCArray, NULL, &status);
2122 if (status == U_MISSING_RESOURCE_ERROR) {
2123 ures_close(ctb);
2124 if (uprv_strcmp(calendarTypeCArray, gGregorianTag) != 0) {
2125 calendarType.setTo(FALSE, kGregorianTagUChar, UPRV_LENGTHOF(kGregorianTagUChar));
2126 calendarSink.visitAllResources();
2127 status = oldStatus;
2128 continue;
2129 }
2130 return;
2131 }
2132
2133 calendarSink.preEnumerate(calendarType);
2134 ures_getAllItemsWithFallback(ctb, "", calendarSink, status);
2135 ures_close(ctb);
2136 if (U_FAILURE(status)) break;
2137
2138 // Stop loading when gregorian was loaded
2139 if (uprv_strcmp(calendarTypeCArray, gGregorianTag) == 0) {
2140 break;
2141 }
2142
2143 // Get the next calendar type to process from the sink
2144 calendarType = calendarSink.nextCalendarType;
2145
2146 // Gregorian is always the last fallback
2147 if (calendarType.isBogus()) {
2148 calendarType.setTo(FALSE, kGregorianTagUChar, UPRV_LENGTHOF(kGregorianTagUChar));
2149 calendarSink.visitAllResources();
2150 }
2151 }
2152
2153 // CharString object to build paths
2154 CharString path;
2155
2156 // Load Leap Month Patterns
2157 UErrorCode tempStatus = status;
2158 fLeapMonthPatterns = newUnicodeStringArray(kMonthPatternsCount);
2159 if (fLeapMonthPatterns) {
2160 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternFormatWide, calendarSink,
2161 buildResourcePath(path, gMonthPatternsTag, gNamesFormatTag, gNamesWideTag, tempStatus), tempStatus);
2162 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternFormatAbbrev, calendarSink,
2163 buildResourcePath(path, gMonthPatternsTag, gNamesFormatTag, gNamesAbbrTag, tempStatus), tempStatus);
2164 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternFormatNarrow, calendarSink,
2165 buildResourcePath(path, gMonthPatternsTag, gNamesFormatTag, gNamesNarrowTag, tempStatus), tempStatus);
2166 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternStandaloneWide, calendarSink,
2167 buildResourcePath(path, gMonthPatternsTag, gNamesStandaloneTag, gNamesWideTag, tempStatus), tempStatus);
2168 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternStandaloneAbbrev, calendarSink,
2169 buildResourcePath(path, gMonthPatternsTag, gNamesStandaloneTag, gNamesAbbrTag, tempStatus), tempStatus);
2170 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternStandaloneNarrow, calendarSink,
2171 buildResourcePath(path, gMonthPatternsTag, gNamesStandaloneTag, gNamesNarrowTag, tempStatus), tempStatus);
2172 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternNumeric, calendarSink,
2173 buildResourcePath(path, gMonthPatternsTag, gNamesNumericTag, gNamesAllTag, tempStatus), tempStatus);
2174 if (U_SUCCESS(tempStatus)) {
2175 // Hack to fix bad C inheritance for dangi monthPatterns (OK in J); this should be handled by aliases in root, but isn't.
2176 // The ordering of the following statements is important.
2177 if (fLeapMonthPatterns[kLeapMonthPatternFormatAbbrev].isEmpty()) {
2178 fLeapMonthPatterns[kLeapMonthPatternFormatAbbrev].setTo(fLeapMonthPatterns[kLeapMonthPatternFormatWide]);
2179 };
2180 if (fLeapMonthPatterns[kLeapMonthPatternFormatNarrow].isEmpty()) {
2181 fLeapMonthPatterns[kLeapMonthPatternFormatNarrow].setTo(fLeapMonthPatterns[kLeapMonthPatternStandaloneNarrow]);
2182 };
2183 if (fLeapMonthPatterns[kLeapMonthPatternStandaloneWide].isEmpty()) {
2184 fLeapMonthPatterns[kLeapMonthPatternStandaloneWide].setTo(fLeapMonthPatterns[kLeapMonthPatternFormatWide]);
2185 };
2186 if (fLeapMonthPatterns[kLeapMonthPatternStandaloneAbbrev].isEmpty()) {
2187 fLeapMonthPatterns[kLeapMonthPatternStandaloneAbbrev].setTo(fLeapMonthPatterns[kLeapMonthPatternFormatAbbrev]);
2188 };
2189 // end of hack
2190 fLeapMonthPatternsCount = kMonthPatternsCount;
2191 } else {
2192 delete[] fLeapMonthPatterns;
2193 fLeapMonthPatterns = NULL;
2194 }
2195 }
2196
2197 // Load cyclic names sets
2198 tempStatus = status;
2199 initField(&fShortYearNames, fShortYearNamesCount, calendarSink,
2200 buildResourcePath(path, gCyclicNameSetsTag, gNameSetYearsTag, gNamesFormatTag, gNamesAbbrTag, tempStatus), tempStatus);
2201 initField(&fShortZodiacNames, fShortZodiacNamesCount, calendarSink,
2202 buildResourcePath(path, gCyclicNameSetsTag, gNameSetZodiacsTag, gNamesFormatTag, gNamesAbbrTag, tempStatus), tempStatus);
2203
2204 // Load context transforms and capitalization
2205 tempStatus = U_ZERO_ERROR;
2206 UResourceBundle *localeBundle = ures_open(NULL, locale.getName(), &tempStatus);
2207 if (U_SUCCESS(tempStatus)) {
2208 UResourceBundle *contextTransforms = ures_getByKeyWithFallback(localeBundle, gContextTransformsTag, NULL, &tempStatus);
2209 if (U_SUCCESS(tempStatus)) {
2210 UResourceBundle *contextTransformUsage;
2211 while ( (contextTransformUsage = ures_getNextResource(contextTransforms, NULL, &tempStatus)) != NULL ) {
2212 const int32_t * intVector = ures_getIntVector(contextTransformUsage, &len, &status);
2213 if (U_SUCCESS(tempStatus) && intVector != NULL && len >= 2) {
2214 const char* usageType = ures_getKey(contextTransformUsage);
2215 if (usageType != NULL) {
2216 const ContextUsageTypeNameToEnumValue * typeMapPtr = contextUsageTypeMap;
2217 int32_t compResult = 0;
2218 // linear search; list is short and we cannot be sure that bsearch is available
2219 while ( typeMapPtr->usageTypeName != NULL && (compResult = uprv_strcmp(usageType, typeMapPtr->usageTypeName)) > 0 ) {
2220 ++typeMapPtr;
2221 }
2222 if (typeMapPtr->usageTypeName != NULL && compResult == 0) {
2223 fCapitalization[typeMapPtr->usageTypeEnumValue][0] = intVector[0];
2224 fCapitalization[typeMapPtr->usageTypeEnumValue][1] = intVector[1];
2225 }
2226 }
2227 }
2228 tempStatus = U_ZERO_ERROR;
2229 ures_close(contextTransformUsage);
2230 }
2231 ures_close(contextTransforms);
2232 }
2233
2234 tempStatus = U_ZERO_ERROR;
2235 const LocalPointer<NumberingSystem> numberingSystem(
2236 NumberingSystem::createInstance(locale, tempStatus), tempStatus);
2237 if (U_SUCCESS(tempStatus)) {
2238 // These functions all fail gracefully if passed NULL pointers and
2239 // do nothing unless U_SUCCESS(tempStatus), so it's only necessary
2240 // to check for errors once after all calls are made.
2241 const LocalUResourceBundlePointer numberElementsData(ures_getByKeyWithFallback(
2242 localeBundle, gNumberElementsTag, NULL, &tempStatus));
2243 const LocalUResourceBundlePointer nsNameData(ures_getByKeyWithFallback(
2244 numberElementsData.getAlias(), numberingSystem->getName(), NULL, &tempStatus));
2245 const LocalUResourceBundlePointer symbolsData(ures_getByKeyWithFallback(
2246 nsNameData.getAlias(), gSymbolsTag, NULL, &tempStatus));
2247 fTimeSeparator = ures_getUnicodeStringByKey(
2248 symbolsData.getAlias(), gTimeSeparatorTag, &tempStatus);
2249 if (U_FAILURE(tempStatus)) {
2250 fTimeSeparator.setToBogus();
2251 }
2252 }
2253
2254 ures_close(localeBundle);
2255 }
2256
2257 if (fTimeSeparator.isBogus()) {
2258 fTimeSeparator.setTo(DateFormatSymbols::DEFAULT_TIME_SEPARATOR);
2259 }
2260
2261 // Load day periods
2262 fWideDayPeriods = loadDayPeriodStrings(calendarSink,
2263 buildResourcePath(path, gDayPeriodTag, gNamesFormatTag, gNamesWideTag, status),
2264 fWideDayPeriodsCount, status);
2265 fNarrowDayPeriods = loadDayPeriodStrings(calendarSink,
2266 buildResourcePath(path, gDayPeriodTag, gNamesFormatTag, gNamesNarrowTag, status),
2267 fNarrowDayPeriodsCount, status);
2268 fAbbreviatedDayPeriods = loadDayPeriodStrings(calendarSink,
2269 buildResourcePath(path, gDayPeriodTag, gNamesFormatTag, gNamesAbbrTag, status),
2270 fAbbreviatedDayPeriodsCount, status);
2271 fStandaloneWideDayPeriods = loadDayPeriodStrings(calendarSink,
2272 buildResourcePath(path, gDayPeriodTag, gNamesStandaloneTag, gNamesWideTag, status),
2273 fStandaloneWideDayPeriodsCount, status);
2274 fStandaloneNarrowDayPeriods = loadDayPeriodStrings(calendarSink,
2275 buildResourcePath(path, gDayPeriodTag, gNamesStandaloneTag, gNamesNarrowTag, status),
2276 fStandaloneNarrowDayPeriodsCount, status);
2277 fStandaloneAbbreviatedDayPeriods = loadDayPeriodStrings(calendarSink,
2278 buildResourcePath(path, gDayPeriodTag, gNamesStandaloneTag, gNamesAbbrTag, status),
2279 fStandaloneAbbreviatedDayPeriodsCount, status);
2280
2281 U_LOCALE_BASED(locBased, *this);
2282 // if we make it to here, the resource data is cool, and we can get everything out
2283 // of it that we need except for the time-zone and localized-pattern data, which
2284 // are stored in a separate file
2285 locBased.setLocaleIDs(ures_getLocaleByType(cb, ULOC_VALID_LOCALE, &status),
2286 ures_getLocaleByType(cb, ULOC_ACTUAL_LOCALE, &status));
2287
2288 // Load eras
2289 initField(&fEras, fErasCount, calendarSink, buildResourcePath(path, gErasTag, gNamesAbbrTag, status), status);
2290 UErrorCode oldStatus = status;
2291 initField(&fEraNames, fEraNamesCount, calendarSink, buildResourcePath(path, gErasTag, gNamesWideTag, status), status);
2292 if (status == U_MISSING_RESOURCE_ERROR) { // Workaround because eras/wide was omitted from CLDR 1.3
2293 status = oldStatus;
2294 assignArray(fEraNames, fEraNamesCount, fEras, fErasCount);
2295 }
2296 // current ICU4J falls back to abbreviated if narrow eras are missing, so we will too
2297 oldStatus = status;
2298 initField(&fNarrowEras, fNarrowErasCount, calendarSink, buildResourcePath(path, gErasTag, gNamesNarrowTag, status), status);
2299 if (status == U_MISSING_RESOURCE_ERROR) { // Workaround because eras/wide was omitted from CLDR 1.3
2300 status = oldStatus;
2301 assignArray(fNarrowEras, fNarrowErasCount, fEras, fErasCount);
2302 }
2303
2304 // Load month names
2305 initField(&fMonths, fMonthsCount, calendarSink,
2306 buildResourcePath(path, gMonthNamesTag, gNamesFormatTag, gNamesWideTag, status), status);
2307 initField(&fShortMonths, fShortMonthsCount, calendarSink,
2308 buildResourcePath(path, gMonthNamesTag, gNamesFormatTag, gNamesAbbrTag, status), status);
2309 initField(&fStandaloneMonths, fStandaloneMonthsCount, calendarSink,
2310 buildResourcePath(path, gMonthNamesTag, gNamesStandaloneTag, gNamesWideTag, status), status);
2311 if (status == U_MISSING_RESOURCE_ERROR) { /* If standalone/wide not available, use format/wide */
2312 status = U_ZERO_ERROR;
2313 assignArray(fStandaloneMonths, fStandaloneMonthsCount, fMonths, fMonthsCount);
2314 }
2315 initField(&fStandaloneShortMonths, fStandaloneShortMonthsCount, calendarSink,
2316 buildResourcePath(path, gMonthNamesTag, gNamesStandaloneTag, gNamesAbbrTag, status), status);
2317 if (status == U_MISSING_RESOURCE_ERROR) { /* If standalone/abbreviated not available, use format/abbreviated */
2318 status = U_ZERO_ERROR;
2319 assignArray(fStandaloneShortMonths, fStandaloneShortMonthsCount, fShortMonths, fShortMonthsCount);
2320 }
2321
2322 UErrorCode narrowMonthsEC = status;
2323 UErrorCode standaloneNarrowMonthsEC = status;
2324 initField(&fNarrowMonths, fNarrowMonthsCount, calendarSink,
2325 buildResourcePath(path, gMonthNamesTag, gNamesFormatTag, gNamesNarrowTag, narrowMonthsEC), narrowMonthsEC);
2326 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, calendarSink,
2327 buildResourcePath(path, gMonthNamesTag, gNamesStandaloneTag, gNamesNarrowTag, narrowMonthsEC), standaloneNarrowMonthsEC);
2328 if (narrowMonthsEC == U_MISSING_RESOURCE_ERROR && standaloneNarrowMonthsEC != U_MISSING_RESOURCE_ERROR) {
2329 // If format/narrow not available, use standalone/narrow
2330 assignArray(fNarrowMonths, fNarrowMonthsCount, fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount);
2331 } else if (narrowMonthsEC != U_MISSING_RESOURCE_ERROR && standaloneNarrowMonthsEC == U_MISSING_RESOURCE_ERROR) {
2332 // If standalone/narrow not availabe, use format/narrow
2333 assignArray(fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, fNarrowMonths, fNarrowMonthsCount);
2334 } else if (narrowMonthsEC == U_MISSING_RESOURCE_ERROR && standaloneNarrowMonthsEC == U_MISSING_RESOURCE_ERROR) {
2335 // If neither is available, use format/abbreviated
2336 assignArray(fNarrowMonths, fNarrowMonthsCount, fShortMonths, fShortMonthsCount);
2337 assignArray(fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, fShortMonths, fShortMonthsCount);
2338 }
2339
2340 // Load AM/PM markers
2341 initField(&fAmPms, fAmPmsCount, calendarSink,
2342 buildResourcePath(path, gAmPmMarkersTag, status), status);
2343 initField(&fNarrowAmPms, fNarrowAmPmsCount, calendarSink,
2344 buildResourcePath(path, gAmPmMarkersNarrowTag, status), status);
2345
2346 // Load quarters
2347 initField(&fQuarters, fQuartersCount, calendarSink,
2348 buildResourcePath(path, gQuartersTag, gNamesFormatTag, gNamesWideTag, status), status);
2349 initField(&fShortQuarters, fShortQuartersCount, calendarSink,
2350 buildResourcePath(path, gQuartersTag, gNamesFormatTag, gNamesAbbrTag, status), status);
2351
2352 initField(&fStandaloneQuarters, fStandaloneQuartersCount, calendarSink,
2353 buildResourcePath(path, gQuartersTag, gNamesStandaloneTag, gNamesWideTag, status), status);
2354 if(status == U_MISSING_RESOURCE_ERROR) {
2355 status = U_ZERO_ERROR;
2356 assignArray(fStandaloneQuarters, fStandaloneQuartersCount, fQuarters, fQuartersCount);
2357 }
2358 initField(&fStandaloneShortQuarters, fStandaloneShortQuartersCount, calendarSink,
2359 buildResourcePath(path, gQuartersTag, gNamesStandaloneTag, gNamesAbbrTag, status), status);
2360 if(status == U_MISSING_RESOURCE_ERROR) {
2361 status = U_ZERO_ERROR;
2362 assignArray(fStandaloneShortQuarters, fStandaloneShortQuartersCount, fShortQuarters, fShortQuartersCount);
2363 }
2364
2365 // ICU 3.8 or later version no longer uses localized date-time pattern characters by default (ticket#5597)
2366 /*
2367 // fastCopyFrom()/setTo() - see assignArray comments
2368 resStr = ures_getStringByKey(fResourceBundle, gLocalPatternCharsTag, &len, &status);
2369 fLocalPatternChars.setTo(TRUE, resStr, len);
2370 // If the locale data does not include new pattern chars, use the defaults
2371 // TODO: Consider making this an error, since this may add conflicting characters.
2372 if (len < PATTERN_CHARS_LEN) {
2373 fLocalPatternChars.append(UnicodeString(TRUE, &gPatternChars[len], PATTERN_CHARS_LEN-len));
2374 }
2375 */
2376 fLocalPatternChars.setTo(TRUE, gPatternChars, PATTERN_CHARS_LEN);
2377
2378 // Format wide weekdays -> fWeekdays
2379 // {sfb} fixed to handle 1-based weekdays
2380 initField(&fWeekdays, fWeekdaysCount, calendarSink,
2381 buildResourcePath(path, gDayNamesTag, gNamesFormatTag, gNamesWideTag, status), 1, status);
2382
2383 // Format abbreviated weekdays -> fShortWeekdays
2384 initField(&fShortWeekdays, fShortWeekdaysCount, calendarSink,
2385 buildResourcePath(path, gDayNamesTag, gNamesFormatTag, gNamesAbbrTag, status), 1, status);
2386
2387 // Format short weekdays -> fShorterWeekdays (fall back to abbreviated)
2388 initField(&fShorterWeekdays, fShorterWeekdaysCount, calendarSink,
2389 buildResourcePath(path, gDayNamesTag, gNamesFormatTag, gNamesShortTag, status), 1, status);
2390 if (status == U_MISSING_RESOURCE_ERROR) {
2391 status = U_ZERO_ERROR;
2392 assignArray(fShorterWeekdays, fShorterWeekdaysCount, fShortWeekdays, fShortWeekdaysCount);
2393 }
2394
2395 // Stand-alone wide weekdays -> fStandaloneWeekdays
2396 initField(&fStandaloneWeekdays, fStandaloneWeekdaysCount, calendarSink,
2397 buildResourcePath(path, gDayNamesTag, gNamesStandaloneTag, gNamesWideTag, status), 1, status);
2398 if (status == U_MISSING_RESOURCE_ERROR) { /* If standalone/wide is not available, use format/wide */
2399 status = U_ZERO_ERROR;
2400 assignArray(fStandaloneWeekdays, fStandaloneWeekdaysCount, fWeekdays, fWeekdaysCount);
2401 }
2402
2403 // Stand-alone abbreviated weekdays -> fStandaloneShortWeekdays
2404 initField(&fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount, calendarSink,
2405 buildResourcePath(path, gDayNamesTag, gNamesStandaloneTag, gNamesAbbrTag, status), 1, status);
2406 if (status == U_MISSING_RESOURCE_ERROR) { /* If standalone/abbreviated is not available, use format/abbreviated */
2407 status = U_ZERO_ERROR;
2408 assignArray(fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount, fShortWeekdays, fShortWeekdaysCount);
2409 }
2410
2411 // Stand-alone short weekdays -> fStandaloneShorterWeekdays (fall back to format abbreviated)
2412 initField(&fStandaloneShorterWeekdays, fStandaloneShorterWeekdaysCount, calendarSink,
2413 buildResourcePath(path, gDayNamesTag, gNamesStandaloneTag, gNamesShortTag, status), 1, status);
2414 if (status == U_MISSING_RESOURCE_ERROR) { /* If standalone/short is not available, use format/short */
2415 status = U_ZERO_ERROR;
2416 assignArray(fStandaloneShorterWeekdays, fStandaloneShorterWeekdaysCount, fShorterWeekdays, fShorterWeekdaysCount);
2417 }
2418
2419 // Format narrow weekdays -> fNarrowWeekdays
2420 UErrorCode narrowWeeksEC = status;
2421 initField(&fNarrowWeekdays, fNarrowWeekdaysCount, calendarSink,
2422 buildResourcePath(path, gDayNamesTag, gNamesFormatTag, gNamesNarrowTag, status), 1, narrowWeeksEC);
2423 // Stand-alone narrow weekdays -> fStandaloneNarrowWeekdays
2424 UErrorCode standaloneNarrowWeeksEC = status;
2425 initField(&fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, calendarSink,
2426 buildResourcePath(path, gDayNamesTag, gNamesStandaloneTag, gNamesNarrowTag, status), 1, standaloneNarrowWeeksEC);
2427
2428 if (narrowWeeksEC == U_MISSING_RESOURCE_ERROR && standaloneNarrowWeeksEC != U_MISSING_RESOURCE_ERROR) {
2429 // If format/narrow not available, use standalone/narrow
2430 assignArray(fNarrowWeekdays, fNarrowWeekdaysCount, fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount);
2431 } else if (narrowWeeksEC != U_MISSING_RESOURCE_ERROR && standaloneNarrowWeeksEC == U_MISSING_RESOURCE_ERROR) {
2432 // If standalone/narrow not available, use format/narrow
2433 assignArray(fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, fNarrowWeekdays, fNarrowWeekdaysCount);
2434 } else if (narrowWeeksEC == U_MISSING_RESOURCE_ERROR && standaloneNarrowWeeksEC == U_MISSING_RESOURCE_ERROR ) {
2435 // If neither is available, use format/abbreviated
2436 assignArray(fNarrowWeekdays, fNarrowWeekdaysCount, fShortWeekdays, fShortWeekdaysCount);
2437 assignArray(fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, fShortWeekdays, fShortWeekdaysCount);
2438 }
2439
2440 // Last resort fallback in case previous data wasn't loaded
2441 if (U_FAILURE(status))
2442 {
2443 if (useLastResortData)
2444 {
2445 // Handle the case in which there is no resource data present.
2446 // We don't have to generate usable patterns in this situation;
2447 // we just need to produce something that will be semi-intelligible
2448 // in most locales.
2449
2450 status = U_USING_FALLBACK_WARNING;
2451 //TODO(fabalbon): make sure we are storing las resort data for all fields in here.
2452 initField(&fEras, fErasCount, (const UChar *)gLastResortEras, kEraNum, kEraLen, status);
2453 initField(&fEraNames, fEraNamesCount, (const UChar *)gLastResortEras, kEraNum, kEraLen, status);
2454 initField(&fNarrowEras, fNarrowErasCount, (const UChar *)gLastResortEras, kEraNum, kEraLen, status);
2455 initField(&fMonths, fMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status);
2456 initField(&fShortMonths, fShortMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status);
2457 initField(&fNarrowMonths, fNarrowMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status);
2458 initField(&fStandaloneMonths, fStandaloneMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status);
2459 initField(&fStandaloneShortMonths, fStandaloneShortMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status);
2460 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status);
2461 initField(&fWeekdays, fWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
2462 initField(&fShortWeekdays, fShortWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
2463 initField(&fShorterWeekdays, fShorterWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
2464 initField(&fNarrowWeekdays, fNarrowWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
2465 initField(&fStandaloneWeekdays, fStandaloneWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
2466 initField(&fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
2467 initField(&fStandaloneShorterWeekdays, fStandaloneShorterWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
2468 initField(&fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status);
2469 initField(&fAmPms, fAmPmsCount, (const UChar *)gLastResortAmPmMarkers, kAmPmNum, kAmPmLen, status);
2470 initField(&fNarrowAmPms, fNarrowAmPmsCount, (const UChar *)gLastResortAmPmMarkers, kAmPmNum, kAmPmLen, status);
2471 initField(&fQuarters, fQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status);
2472 initField(&fShortQuarters, fShortQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status);
2473 initField(&fStandaloneQuarters, fStandaloneQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status);
2474 initField(&fStandaloneShortQuarters, fStandaloneShortQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status);
2475 fLocalPatternChars.setTo(TRUE, gPatternChars, PATTERN_CHARS_LEN);
2476 }
2477 }
2478
2479 // Close resources
2480 ures_close(cb);
2481 ures_close(rb);
2482 }
2483
2484 Locale
getLocale(ULocDataLocaleType type,UErrorCode & status) const2485 DateFormatSymbols::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
2486 U_LOCALE_BASED(locBased, *this);
2487 return locBased.getLocale(type, status);
2488 }
2489
2490 U_NAMESPACE_END
2491
2492 #endif /* #if !UCONFIG_NO_FORMATTING */
2493
2494 //eof
2495