1 /* 2 ******************************************************************************* 3 * Copyright (C) 1997-2015, International Business Machines Corporation and * 4 * others. All Rights Reserved. * 5 ******************************************************************************* 6 * 7 * File DTFMTSYM.CPP 8 * 9 * Modification History: 10 * 11 * Date Name Description 12 * 02/19/97 aliu Converted from java. 13 * 07/21/98 stephen Added getZoneIndex 14 * Changed weekdays/short weekdays to be one-based 15 * 06/14/99 stephen Removed SimpleDateFormat::fgTimeZoneDataSuffix 16 * 11/16/99 weiv Added 'Y' and 'e' to fgPatternChars 17 * 03/27/00 weiv Keeping resource bundle around! 18 * 06/30/05 emmons Added eraNames, narrow month/day, standalone context 19 * 10/12/05 emmons Added setters for eraNames, month/day by width/context 20 ******************************************************************************* 21 */ 22 #include "unicode/utypes.h" 23 24 #if !UCONFIG_NO_FORMATTING 25 #include "unicode/ustring.h" 26 #include "unicode/localpointer.h" 27 #include "unicode/dtfmtsym.h" 28 #include "unicode/smpdtfmt.h" 29 #include "unicode/msgfmt.h" 30 #include "unicode/numsys.h" 31 #include "unicode/tznames.h" 32 #include "cpputils.h" 33 #include "umutex.h" 34 #include "cmemory.h" 35 #include "cstring.h" 36 #include "locbased.h" 37 #include "gregoimp.h" 38 #include "hash.h" 39 #include "uresimp.h" 40 #include "ureslocs.h" 41 #include "shareddateformatsymbols.h" 42 #include "unicode/calendar.h" 43 #include "unifiedcache.h" 44 45 // ***************************************************************************** 46 // class DateFormatSymbols 47 // ***************************************************************************** 48 49 /** 50 * These are static arrays we use only in the case where we have no 51 * resource data. 52 */ 53 54 #define PATTERN_CHARS_LEN 36 55 56 /** 57 * Unlocalized date-time pattern characters. For example: 'y', 'd', etc. All 58 * locales use the same these unlocalized pattern characters. 59 */ 60 static const UChar gPatternChars[] = { 61 // GyMdkHmsSEDFwWahKzYeugAZvcLQqVUOXxr: 62 0x47, 0x79, 0x4D, 0x64, 0x6B, 0x48, 0x6D, 0x73, 0x53, 0x45, 63 0x44, 0x46, 0x77, 0x57, 0x61, 0x68, 0x4B, 0x7A, 0x59, 0x65, 64 0x75, 0x67, 0x41, 0x5A, 0x76, 0x63, 0x4c, 0x51, 0x71, 0x56, 65 0x55, 0x4F, 0x58, 0x78, 0x72, 0x3a, 0 66 }; 67 68 /* length of an array */ 69 #define ARRAY_LENGTH(array) (sizeof(array)/sizeof(array[0])) 70 71 //------------------------------------------------------ 72 // Strings of last resort. These are only used if we have no resource 73 // files. They aren't designed for actual use, just for backup. 74 75 // These are the month names and abbreviations of last resort. 76 static const UChar gLastResortMonthNames[13][3] = 77 { 78 {0x0030, 0x0031, 0x0000}, /* "01" */ 79 {0x0030, 0x0032, 0x0000}, /* "02" */ 80 {0x0030, 0x0033, 0x0000}, /* "03" */ 81 {0x0030, 0x0034, 0x0000}, /* "04" */ 82 {0x0030, 0x0035, 0x0000}, /* "05" */ 83 {0x0030, 0x0036, 0x0000}, /* "06" */ 84 {0x0030, 0x0037, 0x0000}, /* "07" */ 85 {0x0030, 0x0038, 0x0000}, /* "08" */ 86 {0x0030, 0x0039, 0x0000}, /* "09" */ 87 {0x0031, 0x0030, 0x0000}, /* "10" */ 88 {0x0031, 0x0031, 0x0000}, /* "11" */ 89 {0x0031, 0x0032, 0x0000}, /* "12" */ 90 {0x0031, 0x0033, 0x0000} /* "13" */ 91 }; 92 93 // These are the weekday names and abbreviations of last resort. 94 static const UChar gLastResortDayNames[8][2] = 95 { 96 {0x0030, 0x0000}, /* "0" */ 97 {0x0031, 0x0000}, /* "1" */ 98 {0x0032, 0x0000}, /* "2" */ 99 {0x0033, 0x0000}, /* "3" */ 100 {0x0034, 0x0000}, /* "4" */ 101 {0x0035, 0x0000}, /* "5" */ 102 {0x0036, 0x0000}, /* "6" */ 103 {0x0037, 0x0000} /* "7" */ 104 }; 105 106 // These are the quarter names and abbreviations of last resort. 107 static const UChar gLastResortQuarters[4][2] = 108 { 109 {0x0031, 0x0000}, /* "1" */ 110 {0x0032, 0x0000}, /* "2" */ 111 {0x0033, 0x0000}, /* "3" */ 112 {0x0034, 0x0000}, /* "4" */ 113 }; 114 115 // These are the am/pm and BC/AD markers of last resort. 116 static const UChar gLastResortAmPmMarkers[2][3] = 117 { 118 {0x0041, 0x004D, 0x0000}, /* "AM" */ 119 {0x0050, 0x004D, 0x0000} /* "PM" */ 120 }; 121 122 static const UChar gLastResortEras[2][3] = 123 { 124 {0x0042, 0x0043, 0x0000}, /* "BC" */ 125 {0x0041, 0x0044, 0x0000} /* "AD" */ 126 }; 127 128 /* Sizes for the last resort string arrays */ 129 typedef enum LastResortSize { 130 kMonthNum = 13, 131 kMonthLen = 3, 132 133 kDayNum = 8, 134 kDayLen = 2, 135 136 kAmPmNum = 2, 137 kAmPmLen = 3, 138 139 kQuarterNum = 4, 140 kQuarterLen = 2, 141 142 kEraNum = 2, 143 kEraLen = 3, 144 145 kZoneNum = 5, 146 kZoneLen = 4, 147 148 kGmtHourNum = 4, 149 kGmtHourLen = 10 150 } LastResortSize; 151 152 U_NAMESPACE_BEGIN 153 154 SharedDateFormatSymbols::~SharedDateFormatSymbols() { 155 } 156 157 template<> U_I18N_API 158 const SharedDateFormatSymbols * 159 LocaleCacheKey<SharedDateFormatSymbols>::createObject( 160 const void */*unusedContext*/, UErrorCode &status) const { 161 char type[256]; 162 Calendar::getCalendarTypeFromLocale(fLoc, type, UPRV_LENGTHOF(type), status); 163 if (U_FAILURE(status)) { 164 return NULL; 165 } 166 SharedDateFormatSymbols *shared 167 = new SharedDateFormatSymbols(fLoc, type, status); 168 if (shared == NULL) { 169 status = U_MEMORY_ALLOCATION_ERROR; 170 return NULL; 171 } 172 if (U_FAILURE(status)) { 173 delete shared; 174 return NULL; 175 } 176 shared->addRef(); 177 return shared; 178 } 179 180 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateFormatSymbols) 181 182 #define kSUPPLEMENTAL "supplementalData" 183 184 /** 185 * These are the tags we expect to see in normal resource bundle files associated 186 * with a locale and calendar 187 */ 188 static const char gErasTag[]="eras"; 189 static const char gCyclicNameSetsTag[]="cyclicNameSets"; 190 static const char gNameSetYearsTag[]="years"; 191 static const char gNameSetZodiacsTag[]="zodiacs"; 192 static const char gMonthNamesTag[]="monthNames"; 193 static const char gMonthPatternsTag[]="monthPatterns"; 194 static const char gDayNamesTag[]="dayNames"; 195 static const char gNamesWideTag[]="wide"; 196 static const char gNamesAbbrTag[]="abbreviated"; 197 static const char gNamesShortTag[]="short"; 198 static const char gNamesNarrowTag[]="narrow"; 199 static const char gNamesAllTag[]="all"; 200 static const char gNamesLeapTag[]="leap"; 201 static const char gNamesFormatTag[]="format"; 202 static const char gNamesStandaloneTag[]="stand-alone"; 203 static const char gNamesNumericTag[]="numeric"; 204 static const char gAmPmMarkersTag[]="AmPmMarkers"; 205 static const char gAmPmMarkersNarrowTag[]="AmPmMarkersNarrow"; 206 static const char gQuartersTag[]="quarters"; 207 static const char gNumberElementsTag[]="NumberElements"; 208 static const char gSymbolsTag[]="symbols"; 209 static const char gTimeSeparatorTag[]="timeSeparator"; 210 211 // static const char gZoneStringsTag[]="zoneStrings"; 212 213 // static const char gLocalPatternCharsTag[]="localPatternChars"; 214 215 static const char gContextTransformsTag[]="contextTransforms"; 216 217 static UMutex LOCK = U_MUTEX_INITIALIZER; 218 219 /** 220 * Jitterbug 2974: MSVC has a bug whereby new X[0] behaves badly. 221 * Work around this. 222 */ 223 static inline UnicodeString* newUnicodeStringArray(size_t count) { 224 return new UnicodeString[count ? count : 1]; 225 } 226 227 //------------------------------------------------------ 228 229 DateFormatSymbols * U_EXPORT2 230 DateFormatSymbols::createForLocale( 231 const Locale& locale, UErrorCode &status) { 232 const SharedDateFormatSymbols *shared = NULL; 233 UnifiedCache::getByLocale(locale, shared, status); 234 if (U_FAILURE(status)) { 235 return NULL; 236 } 237 DateFormatSymbols *result = new DateFormatSymbols(shared->get()); 238 shared->removeRef(); 239 if (result == NULL) { 240 status = U_MEMORY_ALLOCATION_ERROR; 241 return NULL; 242 } 243 return result; 244 } 245 246 DateFormatSymbols::DateFormatSymbols(const Locale& locale, 247 UErrorCode& status) 248 : UObject() 249 { 250 initializeData(locale, NULL, status); 251 } 252 253 DateFormatSymbols::DateFormatSymbols(UErrorCode& status) 254 : UObject() 255 { 256 initializeData(Locale::getDefault(), NULL, status, TRUE); 257 } 258 259 260 DateFormatSymbols::DateFormatSymbols(const Locale& locale, 261 const char *type, 262 UErrorCode& status) 263 : UObject() 264 { 265 initializeData(locale, type, status); 266 } 267 268 DateFormatSymbols::DateFormatSymbols(const char *type, UErrorCode& status) 269 : UObject() 270 { 271 initializeData(Locale::getDefault(), type, status, TRUE); 272 } 273 274 DateFormatSymbols::DateFormatSymbols(const DateFormatSymbols& other) 275 : UObject(other) 276 { 277 copyData(other); 278 } 279 280 void 281 DateFormatSymbols::assignArray(UnicodeString*& dstArray, 282 int32_t& dstCount, 283 const UnicodeString* srcArray, 284 int32_t srcCount) 285 { 286 // assignArray() is only called by copyData(), which in turn implements the 287 // copy constructor and the assignment operator. 288 // All strings in a DateFormatSymbols object are created in one of the following 289 // three ways that all allow to safely use UnicodeString::fastCopyFrom(): 290 // - readonly-aliases from resource bundles 291 // - readonly-aliases or allocated strings from constants 292 // - safely cloned strings (with owned buffers) from setXYZ() functions 293 // 294 // Note that this is true for as long as DateFormatSymbols can be constructed 295 // only from a locale bundle or set via the cloning API, 296 // *and* for as long as all the strings are in *private* fields, preventing 297 // a subclass from creating these strings in an "unsafe" way (with respect to fastCopyFrom()). 298 dstCount = srcCount; 299 dstArray = newUnicodeStringArray(srcCount); 300 if(dstArray != NULL) { 301 int32_t i; 302 for(i=0; i<srcCount; ++i) { 303 dstArray[i].fastCopyFrom(srcArray[i]); 304 } 305 } 306 } 307 308 /** 309 * Create a copy, in fZoneStrings, of the given zone strings array. The 310 * member variables fZoneStringsRowCount and fZoneStringsColCount should 311 * be set already by the caller. 312 */ 313 void 314 DateFormatSymbols::createZoneStrings(const UnicodeString *const * otherStrings) 315 { 316 int32_t row, col; 317 UBool failed = FALSE; 318 319 fZoneStrings = (UnicodeString **)uprv_malloc(fZoneStringsRowCount * sizeof(UnicodeString *)); 320 if (fZoneStrings != NULL) { 321 for (row=0; row<fZoneStringsRowCount; ++row) 322 { 323 fZoneStrings[row] = newUnicodeStringArray(fZoneStringsColCount); 324 if (fZoneStrings[row] == NULL) { 325 failed = TRUE; 326 break; 327 } 328 for (col=0; col<fZoneStringsColCount; ++col) { 329 // fastCopyFrom() - see assignArray comments 330 fZoneStrings[row][col].fastCopyFrom(otherStrings[row][col]); 331 } 332 } 333 } 334 // If memory allocation failed, roll back and delete fZoneStrings 335 if (failed) { 336 for (int i = row; i >= 0; i--) { 337 delete[] fZoneStrings[i]; 338 } 339 uprv_free(fZoneStrings); 340 fZoneStrings = NULL; 341 } 342 } 343 344 /** 345 * Copy all of the other's data to this. 346 */ 347 void 348 DateFormatSymbols::copyData(const DateFormatSymbols& other) { 349 UErrorCode status = U_ZERO_ERROR; 350 U_LOCALE_BASED(locBased, *this); 351 locBased.setLocaleIDs( 352 other.getLocale(ULOC_VALID_LOCALE, status), 353 other.getLocale(ULOC_ACTUAL_LOCALE, status)); 354 assignArray(fEras, fErasCount, other.fEras, other.fErasCount); 355 assignArray(fEraNames, fEraNamesCount, other.fEraNames, other.fEraNamesCount); 356 assignArray(fNarrowEras, fNarrowErasCount, other.fNarrowEras, other.fNarrowErasCount); 357 assignArray(fMonths, fMonthsCount, other.fMonths, other.fMonthsCount); 358 assignArray(fShortMonths, fShortMonthsCount, other.fShortMonths, other.fShortMonthsCount); 359 assignArray(fNarrowMonths, fNarrowMonthsCount, other.fNarrowMonths, other.fNarrowMonthsCount); 360 assignArray(fStandaloneMonths, fStandaloneMonthsCount, other.fStandaloneMonths, other.fStandaloneMonthsCount); 361 assignArray(fStandaloneShortMonths, fStandaloneShortMonthsCount, other.fStandaloneShortMonths, other.fStandaloneShortMonthsCount); 362 assignArray(fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, other.fStandaloneNarrowMonths, other.fStandaloneNarrowMonthsCount); 363 assignArray(fWeekdays, fWeekdaysCount, other.fWeekdays, other.fWeekdaysCount); 364 assignArray(fShortWeekdays, fShortWeekdaysCount, other.fShortWeekdays, other.fShortWeekdaysCount); 365 assignArray(fShorterWeekdays, fShorterWeekdaysCount, other.fShorterWeekdays, other.fShorterWeekdaysCount); 366 assignArray(fNarrowWeekdays, fNarrowWeekdaysCount, other.fNarrowWeekdays, other.fNarrowWeekdaysCount); 367 assignArray(fStandaloneWeekdays, fStandaloneWeekdaysCount, other.fStandaloneWeekdays, other.fStandaloneWeekdaysCount); 368 assignArray(fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount, other.fStandaloneShortWeekdays, other.fStandaloneShortWeekdaysCount); 369 assignArray(fStandaloneShorterWeekdays, fStandaloneShorterWeekdaysCount, other.fStandaloneShorterWeekdays, other.fStandaloneShorterWeekdaysCount); 370 assignArray(fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, other.fStandaloneNarrowWeekdays, other.fStandaloneNarrowWeekdaysCount); 371 assignArray(fAmPms, fAmPmsCount, other.fAmPms, other.fAmPmsCount); 372 assignArray(fNarrowAmPms, fNarrowAmPmsCount, other.fNarrowAmPms, other.fNarrowAmPmsCount ); 373 fTimeSeparator.fastCopyFrom(other.fTimeSeparator); // fastCopyFrom() - see assignArray comments 374 assignArray(fQuarters, fQuartersCount, other.fQuarters, other.fQuartersCount); 375 assignArray(fShortQuarters, fShortQuartersCount, other.fShortQuarters, other.fShortQuartersCount); 376 assignArray(fStandaloneQuarters, fStandaloneQuartersCount, other.fStandaloneQuarters, other.fStandaloneQuartersCount); 377 assignArray(fStandaloneShortQuarters, fStandaloneShortQuartersCount, other.fStandaloneShortQuarters, other.fStandaloneShortQuartersCount); 378 if (other.fLeapMonthPatterns != NULL) { 379 assignArray(fLeapMonthPatterns, fLeapMonthPatternsCount, other.fLeapMonthPatterns, other.fLeapMonthPatternsCount); 380 } else { 381 fLeapMonthPatterns = NULL; 382 fLeapMonthPatternsCount = 0; 383 } 384 if (other.fShortYearNames != NULL) { 385 assignArray(fShortYearNames, fShortYearNamesCount, other.fShortYearNames, other.fShortYearNamesCount); 386 } else { 387 fShortYearNames = NULL; 388 fShortYearNamesCount = 0; 389 } 390 if (other.fShortZodiacNames != NULL) { 391 assignArray(fShortZodiacNames, fShortZodiacNamesCount, other.fShortZodiacNames, other.fShortZodiacNamesCount); 392 } else { 393 fShortZodiacNames = NULL; 394 fShortZodiacNamesCount = 0; 395 } 396 397 if (other.fZoneStrings != NULL) { 398 fZoneStringsColCount = other.fZoneStringsColCount; 399 fZoneStringsRowCount = other.fZoneStringsRowCount; 400 createZoneStrings((const UnicodeString**)other.fZoneStrings); 401 402 } else { 403 fZoneStrings = NULL; 404 fZoneStringsColCount = 0; 405 fZoneStringsRowCount = 0; 406 } 407 fZSFLocale = other.fZSFLocale; 408 // Other zone strings data is created on demand 409 fLocaleZoneStrings = NULL; 410 411 // fastCopyFrom() - see assignArray comments 412 fLocalPatternChars.fastCopyFrom(other.fLocalPatternChars); 413 414 uprv_memcpy(fCapitalization, other.fCapitalization, sizeof(fCapitalization)); 415 } 416 417 /** 418 * Assignment operator. 419 */ 420 DateFormatSymbols& DateFormatSymbols::operator=(const DateFormatSymbols& other) 421 { 422 dispose(); 423 copyData(other); 424 425 return *this; 426 } 427 428 DateFormatSymbols::~DateFormatSymbols() 429 { 430 dispose(); 431 } 432 433 void DateFormatSymbols::dispose() 434 { 435 if (fEras) delete[] fEras; 436 if (fEraNames) delete[] fEraNames; 437 if (fNarrowEras) delete[] fNarrowEras; 438 if (fMonths) delete[] fMonths; 439 if (fShortMonths) delete[] fShortMonths; 440 if (fNarrowMonths) delete[] fNarrowMonths; 441 if (fStandaloneMonths) delete[] fStandaloneMonths; 442 if (fStandaloneShortMonths) delete[] fStandaloneShortMonths; 443 if (fStandaloneNarrowMonths) delete[] fStandaloneNarrowMonths; 444 if (fWeekdays) delete[] fWeekdays; 445 if (fShortWeekdays) delete[] fShortWeekdays; 446 if (fShorterWeekdays) delete[] fShorterWeekdays; 447 if (fNarrowWeekdays) delete[] fNarrowWeekdays; 448 if (fStandaloneWeekdays) delete[] fStandaloneWeekdays; 449 if (fStandaloneShortWeekdays) delete[] fStandaloneShortWeekdays; 450 if (fStandaloneShorterWeekdays) delete[] fStandaloneShorterWeekdays; 451 if (fStandaloneNarrowWeekdays) delete[] fStandaloneNarrowWeekdays; 452 if (fAmPms) delete[] fAmPms; 453 if (fNarrowAmPms) delete[] fNarrowAmPms; 454 if (fQuarters) delete[] fQuarters; 455 if (fShortQuarters) delete[] fShortQuarters; 456 if (fStandaloneQuarters) delete[] fStandaloneQuarters; 457 if (fStandaloneShortQuarters) delete[] fStandaloneShortQuarters; 458 if (fLeapMonthPatterns) delete[] fLeapMonthPatterns; 459 if (fShortYearNames) delete[] fShortYearNames; 460 if (fShortZodiacNames) delete[] fShortZodiacNames; 461 462 disposeZoneStrings(); 463 } 464 465 void DateFormatSymbols::disposeZoneStrings() 466 { 467 if (fZoneStrings) { 468 for (int32_t row = 0; row < fZoneStringsRowCount; ++row) { 469 delete[] fZoneStrings[row]; 470 } 471 uprv_free(fZoneStrings); 472 } 473 if (fLocaleZoneStrings) { 474 for (int32_t row = 0; row < fZoneStringsRowCount; ++row) { 475 delete[] fLocaleZoneStrings[row]; 476 } 477 uprv_free(fLocaleZoneStrings); 478 } 479 480 fZoneStrings = NULL; 481 fLocaleZoneStrings = NULL; 482 fZoneStringsRowCount = 0; 483 fZoneStringsColCount = 0; 484 } 485 486 UBool 487 DateFormatSymbols::arrayCompare(const UnicodeString* array1, 488 const UnicodeString* array2, 489 int32_t count) 490 { 491 if (array1 == array2) return TRUE; 492 while (count>0) 493 { 494 --count; 495 if (array1[count] != array2[count]) return FALSE; 496 } 497 return TRUE; 498 } 499 500 UBool 501 DateFormatSymbols::operator==(const DateFormatSymbols& other) const 502 { 503 // First do cheap comparisons 504 if (this == &other) { 505 return TRUE; 506 } 507 if (fErasCount == other.fErasCount && 508 fEraNamesCount == other.fEraNamesCount && 509 fNarrowErasCount == other.fNarrowErasCount && 510 fMonthsCount == other.fMonthsCount && 511 fShortMonthsCount == other.fShortMonthsCount && 512 fNarrowMonthsCount == other.fNarrowMonthsCount && 513 fStandaloneMonthsCount == other.fStandaloneMonthsCount && 514 fStandaloneShortMonthsCount == other.fStandaloneShortMonthsCount && 515 fStandaloneNarrowMonthsCount == other.fStandaloneNarrowMonthsCount && 516 fWeekdaysCount == other.fWeekdaysCount && 517 fShortWeekdaysCount == other.fShortWeekdaysCount && 518 fShorterWeekdaysCount == other.fShorterWeekdaysCount && 519 fNarrowWeekdaysCount == other.fNarrowWeekdaysCount && 520 fStandaloneWeekdaysCount == other.fStandaloneWeekdaysCount && 521 fStandaloneShortWeekdaysCount == other.fStandaloneShortWeekdaysCount && 522 fStandaloneShorterWeekdaysCount == other.fStandaloneShorterWeekdaysCount && 523 fStandaloneNarrowWeekdaysCount == other.fStandaloneNarrowWeekdaysCount && 524 fAmPmsCount == other.fAmPmsCount && 525 fNarrowAmPmsCount == other.fNarrowAmPmsCount && 526 fQuartersCount == other.fQuartersCount && 527 fShortQuartersCount == other.fShortQuartersCount && 528 fStandaloneQuartersCount == other.fStandaloneQuartersCount && 529 fStandaloneShortQuartersCount == other.fStandaloneShortQuartersCount && 530 fLeapMonthPatternsCount == other.fLeapMonthPatternsCount && 531 fShortYearNamesCount == other.fShortYearNamesCount && 532 fShortZodiacNamesCount == other.fShortZodiacNamesCount && 533 (uprv_memcmp(fCapitalization, other.fCapitalization, sizeof(fCapitalization))==0)) 534 { 535 // Now compare the arrays themselves 536 if (arrayCompare(fEras, other.fEras, fErasCount) && 537 arrayCompare(fEraNames, other.fEraNames, fEraNamesCount) && 538 arrayCompare(fNarrowEras, other.fNarrowEras, fNarrowErasCount) && 539 arrayCompare(fMonths, other.fMonths, fMonthsCount) && 540 arrayCompare(fShortMonths, other.fShortMonths, fShortMonthsCount) && 541 arrayCompare(fNarrowMonths, other.fNarrowMonths, fNarrowMonthsCount) && 542 arrayCompare(fStandaloneMonths, other.fStandaloneMonths, fStandaloneMonthsCount) && 543 arrayCompare(fStandaloneShortMonths, other.fStandaloneShortMonths, fStandaloneShortMonthsCount) && 544 arrayCompare(fStandaloneNarrowMonths, other.fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount) && 545 arrayCompare(fWeekdays, other.fWeekdays, fWeekdaysCount) && 546 arrayCompare(fShortWeekdays, other.fShortWeekdays, fShortWeekdaysCount) && 547 arrayCompare(fShorterWeekdays, other.fShorterWeekdays, fShorterWeekdaysCount) && 548 arrayCompare(fNarrowWeekdays, other.fNarrowWeekdays, fNarrowWeekdaysCount) && 549 arrayCompare(fStandaloneWeekdays, other.fStandaloneWeekdays, fStandaloneWeekdaysCount) && 550 arrayCompare(fStandaloneShortWeekdays, other.fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount) && 551 arrayCompare(fStandaloneShorterWeekdays, other.fStandaloneShorterWeekdays, fStandaloneShorterWeekdaysCount) && 552 arrayCompare(fStandaloneNarrowWeekdays, other.fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount) && 553 arrayCompare(fAmPms, other.fAmPms, fAmPmsCount) && 554 arrayCompare(fNarrowAmPms, other.fNarrowAmPms, fNarrowAmPmsCount) && 555 fTimeSeparator == other.fTimeSeparator && 556 arrayCompare(fQuarters, other.fQuarters, fQuartersCount) && 557 arrayCompare(fShortQuarters, other.fShortQuarters, fShortQuartersCount) && 558 arrayCompare(fStandaloneQuarters, other.fStandaloneQuarters, fStandaloneQuartersCount) && 559 arrayCompare(fStandaloneShortQuarters, other.fStandaloneShortQuarters, fStandaloneShortQuartersCount) && 560 arrayCompare(fLeapMonthPatterns, other.fLeapMonthPatterns, fLeapMonthPatternsCount) && 561 arrayCompare(fShortYearNames, other.fShortYearNames, fShortYearNamesCount) && 562 arrayCompare(fShortZodiacNames, other.fShortZodiacNames, fShortZodiacNamesCount)) 563 { 564 // Compare the contents of fZoneStrings 565 if (fZoneStrings == NULL && other.fZoneStrings == NULL) { 566 if (fZSFLocale == other.fZSFLocale) { 567 return TRUE; 568 } 569 } else if (fZoneStrings != NULL && other.fZoneStrings != NULL) { 570 if (fZoneStringsRowCount == other.fZoneStringsRowCount 571 && fZoneStringsColCount == other.fZoneStringsColCount) { 572 UBool cmpres = TRUE; 573 for (int32_t i = 0; (i < fZoneStringsRowCount) && cmpres; i++) { 574 cmpres = arrayCompare(fZoneStrings[i], other.fZoneStrings[i], fZoneStringsColCount); 575 } 576 return cmpres; 577 } 578 } 579 return FALSE; 580 } 581 } 582 return FALSE; 583 } 584 585 //------------------------------------------------------ 586 587 const UnicodeString* 588 DateFormatSymbols::getEras(int32_t &count) const 589 { 590 count = fErasCount; 591 return fEras; 592 } 593 594 const UnicodeString* 595 DateFormatSymbols::getEraNames(int32_t &count) const 596 { 597 count = fEraNamesCount; 598 return fEraNames; 599 } 600 601 const UnicodeString* 602 DateFormatSymbols::getNarrowEras(int32_t &count) const 603 { 604 count = fNarrowErasCount; 605 return fNarrowEras; 606 } 607 608 const UnicodeString* 609 DateFormatSymbols::getMonths(int32_t &count) const 610 { 611 count = fMonthsCount; 612 return fMonths; 613 } 614 615 const UnicodeString* 616 DateFormatSymbols::getShortMonths(int32_t &count) const 617 { 618 count = fShortMonthsCount; 619 return fShortMonths; 620 } 621 622 const UnicodeString* 623 DateFormatSymbols::getMonths(int32_t &count, DtContextType context, DtWidthType width ) const 624 { 625 UnicodeString *returnValue = NULL; 626 627 switch (context) { 628 case FORMAT : 629 switch(width) { 630 case WIDE : 631 count = fMonthsCount; 632 returnValue = fMonths; 633 break; 634 case ABBREVIATED : 635 case SHORT : // no month data for this, defaults to ABBREVIATED 636 count = fShortMonthsCount; 637 returnValue = fShortMonths; 638 break; 639 case NARROW : 640 count = fNarrowMonthsCount; 641 returnValue = fNarrowMonths; 642 break; 643 case DT_WIDTH_COUNT : 644 break; 645 } 646 break; 647 case STANDALONE : 648 switch(width) { 649 case WIDE : 650 count = fStandaloneMonthsCount; 651 returnValue = fStandaloneMonths; 652 break; 653 case ABBREVIATED : 654 case SHORT : // no month data for this, defaults to ABBREVIATED 655 count = fStandaloneShortMonthsCount; 656 returnValue = fStandaloneShortMonths; 657 break; 658 case NARROW : 659 count = fStandaloneNarrowMonthsCount; 660 returnValue = fStandaloneNarrowMonths; 661 break; 662 case DT_WIDTH_COUNT : 663 break; 664 } 665 break; 666 case DT_CONTEXT_COUNT : 667 break; 668 } 669 return returnValue; 670 } 671 672 const UnicodeString* 673 DateFormatSymbols::getWeekdays(int32_t &count) const 674 { 675 count = fWeekdaysCount; 676 return fWeekdays; 677 } 678 679 const UnicodeString* 680 DateFormatSymbols::getShortWeekdays(int32_t &count) const 681 { 682 count = fShortWeekdaysCount; 683 return fShortWeekdays; 684 } 685 686 const UnicodeString* 687 DateFormatSymbols::getWeekdays(int32_t &count, DtContextType context, DtWidthType width) const 688 { 689 UnicodeString *returnValue = NULL; 690 switch (context) { 691 case FORMAT : 692 switch(width) { 693 case WIDE : 694 count = fWeekdaysCount; 695 returnValue = fWeekdays; 696 break; 697 case ABBREVIATED : 698 count = fShortWeekdaysCount; 699 returnValue = fShortWeekdays; 700 break; 701 case SHORT : 702 count = fShorterWeekdaysCount; 703 returnValue = fShorterWeekdays; 704 break; 705 case NARROW : 706 count = fNarrowWeekdaysCount; 707 returnValue = fNarrowWeekdays; 708 break; 709 case DT_WIDTH_COUNT : 710 break; 711 } 712 break; 713 case STANDALONE : 714 switch(width) { 715 case WIDE : 716 count = fStandaloneWeekdaysCount; 717 returnValue = fStandaloneWeekdays; 718 break; 719 case ABBREVIATED : 720 count = fStandaloneShortWeekdaysCount; 721 returnValue = fStandaloneShortWeekdays; 722 break; 723 case SHORT : 724 count = fStandaloneShorterWeekdaysCount; 725 returnValue = fStandaloneShorterWeekdays; 726 break; 727 case NARROW : 728 count = fStandaloneNarrowWeekdaysCount; 729 returnValue = fStandaloneNarrowWeekdays; 730 break; 731 case DT_WIDTH_COUNT : 732 break; 733 } 734 break; 735 case DT_CONTEXT_COUNT : 736 break; 737 } 738 return returnValue; 739 } 740 741 const UnicodeString* 742 DateFormatSymbols::getQuarters(int32_t &count, DtContextType context, DtWidthType width ) const 743 { 744 UnicodeString *returnValue = NULL; 745 746 switch (context) { 747 case FORMAT : 748 switch(width) { 749 case WIDE : 750 count = fQuartersCount; 751 returnValue = fQuarters; 752 break; 753 case ABBREVIATED : 754 case SHORT : // no quarter data for this, defaults to ABBREVIATED 755 count = fShortQuartersCount; 756 returnValue = fShortQuarters; 757 break; 758 case NARROW : 759 count = 0; 760 returnValue = NULL; 761 break; 762 case DT_WIDTH_COUNT : 763 break; 764 } 765 break; 766 case STANDALONE : 767 switch(width) { 768 case WIDE : 769 count = fStandaloneQuartersCount; 770 returnValue = fStandaloneQuarters; 771 break; 772 case ABBREVIATED : 773 case SHORT : // no quarter data for this, defaults to ABBREVIATED 774 count = fStandaloneShortQuartersCount; 775 returnValue = fStandaloneShortQuarters; 776 break; 777 case NARROW : 778 count = 0; 779 returnValue = NULL; 780 break; 781 case DT_WIDTH_COUNT : 782 break; 783 } 784 break; 785 case DT_CONTEXT_COUNT : 786 break; 787 } 788 return returnValue; 789 } 790 791 UnicodeString& 792 DateFormatSymbols::getTimeSeparatorString(UnicodeString& result) const 793 { 794 // fastCopyFrom() - see assignArray comments 795 return result.fastCopyFrom(fTimeSeparator); 796 } 797 798 const UnicodeString* 799 DateFormatSymbols::getAmPmStrings(int32_t &count) const 800 { 801 count = fAmPmsCount; 802 return fAmPms; 803 } 804 805 const UnicodeString* 806 DateFormatSymbols::getLeapMonthPatterns(int32_t &count) const 807 { 808 count = fLeapMonthPatternsCount; 809 return fLeapMonthPatterns; 810 } 811 812 const UnicodeString* 813 DateFormatSymbols::getYearNames(int32_t& count, 814 DtContextType /*ignored*/, DtWidthType /*ignored*/) const 815 { 816 count = fShortYearNamesCount; 817 return fShortYearNames; 818 } 819 820 void 821 DateFormatSymbols::setYearNames(const UnicodeString* yearNames, int32_t count, 822 DtContextType context, DtWidthType width) 823 { 824 if (context == FORMAT && width == ABBREVIATED) { 825 if (fShortYearNames) { 826 delete[] fShortYearNames; 827 } 828 fShortYearNames = newUnicodeStringArray(count); 829 uprv_arrayCopy(yearNames, fShortYearNames, count); 830 fShortYearNamesCount = count; 831 } 832 } 833 834 const UnicodeString* 835 DateFormatSymbols::getZodiacNames(int32_t& count, 836 DtContextType /*ignored*/, DtWidthType /*ignored*/) const 837 { 838 count = fShortZodiacNamesCount; 839 return fShortZodiacNames; 840 } 841 842 void 843 DateFormatSymbols::setZodiacNames(const UnicodeString* zodiacNames, int32_t count, 844 DtContextType context, DtWidthType width) 845 { 846 if (context == FORMAT && width == ABBREVIATED) { 847 if (fShortZodiacNames) { 848 delete[] fShortZodiacNames; 849 } 850 fShortZodiacNames = newUnicodeStringArray(count); 851 uprv_arrayCopy(zodiacNames, fShortZodiacNames, count); 852 fShortZodiacNamesCount = count; 853 } 854 } 855 856 //------------------------------------------------------ 857 858 void 859 DateFormatSymbols::setEras(const UnicodeString* erasArray, int32_t count) 860 { 861 // delete the old list if we own it 862 if (fEras) 863 delete[] fEras; 864 865 // we always own the new list, which we create here (we duplicate rather 866 // than adopting the list passed in) 867 fEras = newUnicodeStringArray(count); 868 uprv_arrayCopy(erasArray,fEras, count); 869 fErasCount = count; 870 } 871 872 void 873 DateFormatSymbols::setEraNames(const UnicodeString* eraNamesArray, int32_t count) 874 { 875 // delete the old list if we own it 876 if (fEraNames) 877 delete[] fEraNames; 878 879 // we always own the new list, which we create here (we duplicate rather 880 // than adopting the list passed in) 881 fEraNames = newUnicodeStringArray(count); 882 uprv_arrayCopy(eraNamesArray,fEraNames, count); 883 fEraNamesCount = count; 884 } 885 886 void 887 DateFormatSymbols::setNarrowEras(const UnicodeString* narrowErasArray, int32_t count) 888 { 889 // delete the old list if we own it 890 if (fNarrowEras) 891 delete[] fNarrowEras; 892 893 // we always own the new list, which we create here (we duplicate rather 894 // than adopting the list passed in) 895 fNarrowEras = newUnicodeStringArray(count); 896 uprv_arrayCopy(narrowErasArray,fNarrowEras, count); 897 fNarrowErasCount = count; 898 } 899 900 void 901 DateFormatSymbols::setMonths(const UnicodeString* monthsArray, int32_t count) 902 { 903 // delete the old list if we own it 904 if (fMonths) 905 delete[] fMonths; 906 907 // we always own the new list, which we create here (we duplicate rather 908 // than adopting the list passed in) 909 fMonths = newUnicodeStringArray(count); 910 uprv_arrayCopy( monthsArray,fMonths,count); 911 fMonthsCount = count; 912 } 913 914 void 915 DateFormatSymbols::setShortMonths(const UnicodeString* shortMonthsArray, int32_t count) 916 { 917 // delete the old list if we own it 918 if (fShortMonths) 919 delete[] fShortMonths; 920 921 // we always own the new list, which we create here (we duplicate rather 922 // than adopting the list passed in) 923 fShortMonths = newUnicodeStringArray(count); 924 uprv_arrayCopy(shortMonthsArray,fShortMonths, count); 925 fShortMonthsCount = count; 926 } 927 928 void 929 DateFormatSymbols::setMonths(const UnicodeString* monthsArray, int32_t count, DtContextType context, DtWidthType width) 930 { 931 // delete the old list if we own it 932 // we always own the new list, which we create here (we duplicate rather 933 // than adopting the list passed in) 934 935 switch (context) { 936 case FORMAT : 937 switch (width) { 938 case WIDE : 939 if (fMonths) 940 delete[] fMonths; 941 fMonths = newUnicodeStringArray(count); 942 uprv_arrayCopy( monthsArray,fMonths,count); 943 fMonthsCount = count; 944 break; 945 case ABBREVIATED : 946 if (fShortMonths) 947 delete[] fShortMonths; 948 fShortMonths = newUnicodeStringArray(count); 949 uprv_arrayCopy( monthsArray,fShortMonths,count); 950 fShortMonthsCount = count; 951 break; 952 case NARROW : 953 if (fNarrowMonths) 954 delete[] fNarrowMonths; 955 fNarrowMonths = newUnicodeStringArray(count); 956 uprv_arrayCopy( monthsArray,fNarrowMonths,count); 957 fNarrowMonthsCount = count; 958 break; 959 default : 960 break; 961 } 962 break; 963 case STANDALONE : 964 switch (width) { 965 case WIDE : 966 if (fStandaloneMonths) 967 delete[] fStandaloneMonths; 968 fStandaloneMonths = newUnicodeStringArray(count); 969 uprv_arrayCopy( monthsArray,fStandaloneMonths,count); 970 fStandaloneMonthsCount = count; 971 break; 972 case ABBREVIATED : 973 if (fStandaloneShortMonths) 974 delete[] fStandaloneShortMonths; 975 fStandaloneShortMonths = newUnicodeStringArray(count); 976 uprv_arrayCopy( monthsArray,fStandaloneShortMonths,count); 977 fStandaloneShortMonthsCount = count; 978 break; 979 case NARROW : 980 if (fStandaloneNarrowMonths) 981 delete[] fStandaloneNarrowMonths; 982 fStandaloneNarrowMonths = newUnicodeStringArray(count); 983 uprv_arrayCopy( monthsArray,fStandaloneNarrowMonths,count); 984 fStandaloneNarrowMonthsCount = count; 985 break; 986 default : 987 break; 988 } 989 break; 990 case DT_CONTEXT_COUNT : 991 break; 992 } 993 } 994 995 void DateFormatSymbols::setWeekdays(const UnicodeString* weekdaysArray, int32_t count) 996 { 997 // delete the old list if we own it 998 if (fWeekdays) 999 delete[] fWeekdays; 1000 1001 // we always own the new list, which we create here (we duplicate rather 1002 // than adopting the list passed in) 1003 fWeekdays = newUnicodeStringArray(count); 1004 uprv_arrayCopy(weekdaysArray,fWeekdays,count); 1005 fWeekdaysCount = count; 1006 } 1007 1008 void 1009 DateFormatSymbols::setShortWeekdays(const UnicodeString* shortWeekdaysArray, int32_t count) 1010 { 1011 // delete the old list if we own it 1012 if (fShortWeekdays) 1013 delete[] fShortWeekdays; 1014 1015 // we always own the new list, which we create here (we duplicate rather 1016 // than adopting the list passed in) 1017 fShortWeekdays = newUnicodeStringArray(count); 1018 uprv_arrayCopy(shortWeekdaysArray, fShortWeekdays, count); 1019 fShortWeekdaysCount = count; 1020 } 1021 1022 void 1023 DateFormatSymbols::setWeekdays(const UnicodeString* weekdaysArray, int32_t count, DtContextType context, DtWidthType width) 1024 { 1025 // delete the old list if we own it 1026 // we always own the new list, which we create here (we duplicate rather 1027 // than adopting the list passed in) 1028 1029 switch (context) { 1030 case FORMAT : 1031 switch (width) { 1032 case WIDE : 1033 if (fWeekdays) 1034 delete[] fWeekdays; 1035 fWeekdays = newUnicodeStringArray(count); 1036 uprv_arrayCopy(weekdaysArray, fWeekdays, count); 1037 fWeekdaysCount = count; 1038 break; 1039 case ABBREVIATED : 1040 if (fShortWeekdays) 1041 delete[] fShortWeekdays; 1042 fShortWeekdays = newUnicodeStringArray(count); 1043 uprv_arrayCopy(weekdaysArray, fShortWeekdays, count); 1044 fShortWeekdaysCount = count; 1045 break; 1046 case SHORT : 1047 if (fShorterWeekdays) 1048 delete[] fShorterWeekdays; 1049 fShorterWeekdays = newUnicodeStringArray(count); 1050 uprv_arrayCopy(weekdaysArray, fShorterWeekdays, count); 1051 fShorterWeekdaysCount = count; 1052 break; 1053 case NARROW : 1054 if (fNarrowWeekdays) 1055 delete[] fNarrowWeekdays; 1056 fNarrowWeekdays = newUnicodeStringArray(count); 1057 uprv_arrayCopy(weekdaysArray, fNarrowWeekdays, count); 1058 fNarrowWeekdaysCount = count; 1059 break; 1060 case DT_WIDTH_COUNT : 1061 break; 1062 } 1063 break; 1064 case STANDALONE : 1065 switch (width) { 1066 case WIDE : 1067 if (fStandaloneWeekdays) 1068 delete[] fStandaloneWeekdays; 1069 fStandaloneWeekdays = newUnicodeStringArray(count); 1070 uprv_arrayCopy(weekdaysArray, fStandaloneWeekdays, count); 1071 fStandaloneWeekdaysCount = count; 1072 break; 1073 case ABBREVIATED : 1074 if (fStandaloneShortWeekdays) 1075 delete[] fStandaloneShortWeekdays; 1076 fStandaloneShortWeekdays = newUnicodeStringArray(count); 1077 uprv_arrayCopy(weekdaysArray, fStandaloneShortWeekdays, count); 1078 fStandaloneShortWeekdaysCount = count; 1079 break; 1080 case SHORT : 1081 if (fStandaloneShorterWeekdays) 1082 delete[] fStandaloneShorterWeekdays; 1083 fStandaloneShorterWeekdays = newUnicodeStringArray(count); 1084 uprv_arrayCopy(weekdaysArray, fStandaloneShorterWeekdays, count); 1085 fStandaloneShorterWeekdaysCount = count; 1086 break; 1087 case NARROW : 1088 if (fStandaloneNarrowWeekdays) 1089 delete[] fStandaloneNarrowWeekdays; 1090 fStandaloneNarrowWeekdays = newUnicodeStringArray(count); 1091 uprv_arrayCopy(weekdaysArray, fStandaloneNarrowWeekdays, count); 1092 fStandaloneNarrowWeekdaysCount = count; 1093 break; 1094 case DT_WIDTH_COUNT : 1095 break; 1096 } 1097 break; 1098 case DT_CONTEXT_COUNT : 1099 break; 1100 } 1101 } 1102 1103 void 1104 DateFormatSymbols::setQuarters(const UnicodeString* quartersArray, int32_t count, DtContextType context, DtWidthType width) 1105 { 1106 // delete the old list if we own it 1107 // we always own the new list, which we create here (we duplicate rather 1108 // than adopting the list passed in) 1109 1110 switch (context) { 1111 case FORMAT : 1112 switch (width) { 1113 case WIDE : 1114 if (fQuarters) 1115 delete[] fQuarters; 1116 fQuarters = newUnicodeStringArray(count); 1117 uprv_arrayCopy( quartersArray,fQuarters,count); 1118 fQuartersCount = count; 1119 break; 1120 case ABBREVIATED : 1121 if (fShortQuarters) 1122 delete[] fShortQuarters; 1123 fShortQuarters = newUnicodeStringArray(count); 1124 uprv_arrayCopy( quartersArray,fShortQuarters,count); 1125 fShortQuartersCount = count; 1126 break; 1127 case NARROW : 1128 /* 1129 if (fNarrowQuarters) 1130 delete[] fNarrowQuarters; 1131 fNarrowQuarters = newUnicodeStringArray(count); 1132 uprv_arrayCopy( quartersArray,fNarrowQuarters,count); 1133 fNarrowQuartersCount = count; 1134 */ 1135 break; 1136 default : 1137 break; 1138 } 1139 break; 1140 case STANDALONE : 1141 switch (width) { 1142 case WIDE : 1143 if (fStandaloneQuarters) 1144 delete[] fStandaloneQuarters; 1145 fStandaloneQuarters = newUnicodeStringArray(count); 1146 uprv_arrayCopy( quartersArray,fStandaloneQuarters,count); 1147 fStandaloneQuartersCount = count; 1148 break; 1149 case ABBREVIATED : 1150 if (fStandaloneShortQuarters) 1151 delete[] fStandaloneShortQuarters; 1152 fStandaloneShortQuarters = newUnicodeStringArray(count); 1153 uprv_arrayCopy( quartersArray,fStandaloneShortQuarters,count); 1154 fStandaloneShortQuartersCount = count; 1155 break; 1156 case NARROW : 1157 /* 1158 if (fStandaloneNarrowQuarters) 1159 delete[] fStandaloneNarrowQuarters; 1160 fStandaloneNarrowQuarters = newUnicodeStringArray(count); 1161 uprv_arrayCopy( quartersArray,fStandaloneNarrowQuarters,count); 1162 fStandaloneNarrowQuartersCount = count; 1163 */ 1164 break; 1165 default : 1166 break; 1167 } 1168 break; 1169 case DT_CONTEXT_COUNT : 1170 break; 1171 } 1172 } 1173 1174 void 1175 DateFormatSymbols::setAmPmStrings(const UnicodeString* amPmsArray, int32_t count) 1176 { 1177 // delete the old list if we own it 1178 if (fAmPms) delete[] fAmPms; 1179 1180 // we always own the new list, which we create here (we duplicate rather 1181 // than adopting the list passed in) 1182 fAmPms = newUnicodeStringArray(count); 1183 uprv_arrayCopy(amPmsArray,fAmPms,count); 1184 fAmPmsCount = count; 1185 } 1186 1187 void 1188 DateFormatSymbols::setTimeSeparatorString(const UnicodeString& newTimeSeparator) 1189 { 1190 fTimeSeparator = newTimeSeparator; 1191 } 1192 1193 const UnicodeString** 1194 DateFormatSymbols::getZoneStrings(int32_t& rowCount, int32_t& columnCount) const 1195 { 1196 const UnicodeString **result = NULL; 1197 1198 umtx_lock(&LOCK); 1199 if (fZoneStrings == NULL) { 1200 if (fLocaleZoneStrings == NULL) { 1201 ((DateFormatSymbols*)this)->initZoneStringsArray(); 1202 } 1203 result = (const UnicodeString**)fLocaleZoneStrings; 1204 } else { 1205 result = (const UnicodeString**)fZoneStrings; 1206 } 1207 rowCount = fZoneStringsRowCount; 1208 columnCount = fZoneStringsColCount; 1209 umtx_unlock(&LOCK); 1210 1211 return result; 1212 } 1213 1214 // For now, we include all zones 1215 #define ZONE_SET UCAL_ZONE_TYPE_ANY 1216 1217 // This code must be called within a synchronized block 1218 void 1219 DateFormatSymbols::initZoneStringsArray(void) { 1220 if (fZoneStrings != NULL || fLocaleZoneStrings != NULL) { 1221 return; 1222 } 1223 1224 UErrorCode status = U_ZERO_ERROR; 1225 1226 StringEnumeration *tzids = NULL; 1227 UnicodeString ** zarray = NULL; 1228 TimeZoneNames *tzNames = NULL; 1229 int32_t rows = 0; 1230 1231 do { // dummy do-while 1232 1233 tzids = TimeZone::createTimeZoneIDEnumeration(ZONE_SET, NULL, NULL, status); 1234 rows = tzids->count(status); 1235 if (U_FAILURE(status)) { 1236 break; 1237 } 1238 1239 // Allocate array 1240 int32_t size = rows * sizeof(UnicodeString*); 1241 zarray = (UnicodeString**)uprv_malloc(size); 1242 if (zarray == NULL) { 1243 status = U_MEMORY_ALLOCATION_ERROR; 1244 break; 1245 } 1246 uprv_memset(zarray, 0, size); 1247 1248 tzNames = TimeZoneNames::createInstance(fZSFLocale, status); 1249 1250 const UnicodeString *tzid; 1251 int32_t i = 0; 1252 UDate now = Calendar::getNow(); 1253 UnicodeString tzDispName; 1254 1255 while ((tzid = tzids->snext(status))) { 1256 if (U_FAILURE(status)) { 1257 break; 1258 } 1259 1260 zarray[i] = new UnicodeString[5]; 1261 if (zarray[i] == NULL) { 1262 status = U_MEMORY_ALLOCATION_ERROR; 1263 break; 1264 } 1265 1266 zarray[i][0].setTo(*tzid); 1267 zarray[i][1].setTo(tzNames->getDisplayName(*tzid, UTZNM_LONG_STANDARD, now, tzDispName)); 1268 zarray[i][2].setTo(tzNames->getDisplayName(*tzid, UTZNM_SHORT_STANDARD, now, tzDispName)); 1269 zarray[i][3].setTo(tzNames->getDisplayName(*tzid, UTZNM_LONG_DAYLIGHT, now, tzDispName)); 1270 zarray[i][4].setTo(tzNames->getDisplayName(*tzid, UTZNM_SHORT_DAYLIGHT, now, tzDispName)); 1271 i++; 1272 } 1273 1274 } while (FALSE); 1275 1276 if (U_FAILURE(status)) { 1277 if (zarray) { 1278 for (int32_t i = 0; i < rows; i++) { 1279 if (zarray[i]) { 1280 delete[] zarray[i]; 1281 } 1282 } 1283 uprv_free(zarray); 1284 } 1285 } 1286 1287 if (tzNames) { 1288 delete tzNames; 1289 } 1290 if (tzids) { 1291 delete tzids; 1292 } 1293 1294 fLocaleZoneStrings = zarray; 1295 fZoneStringsRowCount = rows; 1296 fZoneStringsColCount = 5; 1297 } 1298 1299 void 1300 DateFormatSymbols::setZoneStrings(const UnicodeString* const *strings, int32_t rowCount, int32_t columnCount) 1301 { 1302 // since deleting a 2-d array is a pain in the butt, we offload that task to 1303 // a separate function 1304 disposeZoneStrings(); 1305 // we always own the new list, which we create here (we duplicate rather 1306 // than adopting the list passed in) 1307 fZoneStringsRowCount = rowCount; 1308 fZoneStringsColCount = columnCount; 1309 createZoneStrings((const UnicodeString**)strings); 1310 } 1311 1312 //------------------------------------------------------ 1313 1314 const UChar * U_EXPORT2 1315 DateFormatSymbols::getPatternUChars(void) 1316 { 1317 return gPatternChars; 1318 } 1319 1320 UDateFormatField U_EXPORT2 1321 DateFormatSymbols::getPatternCharIndex(UChar c) { 1322 const UChar *p = u_strchr(gPatternChars, c); 1323 if (p == NULL) { 1324 return UDAT_FIELD_COUNT; 1325 } else { 1326 return static_cast<UDateFormatField>(p - gPatternChars); 1327 } 1328 } 1329 1330 static const uint64_t kNumericFieldsAlways = 1331 ((uint64_t)1 << UDAT_YEAR_FIELD) | // y 1332 ((uint64_t)1 << UDAT_DATE_FIELD) | // d 1333 ((uint64_t)1 << UDAT_HOUR_OF_DAY1_FIELD) | // k 1334 ((uint64_t)1 << UDAT_HOUR_OF_DAY0_FIELD) | // H 1335 ((uint64_t)1 << UDAT_MINUTE_FIELD) | // m 1336 ((uint64_t)1 << UDAT_SECOND_FIELD) | // s 1337 ((uint64_t)1 << UDAT_FRACTIONAL_SECOND_FIELD) | // S 1338 ((uint64_t)1 << UDAT_DAY_OF_YEAR_FIELD) | // D 1339 ((uint64_t)1 << UDAT_DAY_OF_WEEK_IN_MONTH_FIELD) | // F 1340 ((uint64_t)1 << UDAT_WEEK_OF_YEAR_FIELD) | // w 1341 ((uint64_t)1 << UDAT_WEEK_OF_MONTH_FIELD) | // W 1342 ((uint64_t)1 << UDAT_HOUR1_FIELD) | // h 1343 ((uint64_t)1 << UDAT_HOUR0_FIELD) | // K 1344 ((uint64_t)1 << UDAT_YEAR_WOY_FIELD) | // Y 1345 ((uint64_t)1 << UDAT_EXTENDED_YEAR_FIELD) | // u 1346 ((uint64_t)1 << UDAT_JULIAN_DAY_FIELD) | // g 1347 ((uint64_t)1 << UDAT_MILLISECONDS_IN_DAY_FIELD) | // A 1348 ((uint64_t)1 << UDAT_RELATED_YEAR_FIELD); // r 1349 1350 static const uint64_t kNumericFieldsForCount12 = 1351 ((uint64_t)1 << UDAT_MONTH_FIELD) | // M or MM 1352 ((uint64_t)1 << UDAT_DOW_LOCAL_FIELD) | // e or ee 1353 ((uint64_t)1 << UDAT_STANDALONE_DAY_FIELD) | // c or cc 1354 ((uint64_t)1 << UDAT_STANDALONE_MONTH_FIELD) | // L or LL 1355 ((uint64_t)1 << UDAT_QUARTER_FIELD) | // Q or QQ 1356 ((uint64_t)1 << UDAT_STANDALONE_QUARTER_FIELD); // q or qq 1357 1358 UBool U_EXPORT2 1359 DateFormatSymbols::isNumericField(UDateFormatField f, int32_t count) { 1360 if (f == UDAT_FIELD_COUNT) { 1361 return FALSE; 1362 } 1363 uint64_t flag = ((uint64_t)1 << f); 1364 return ((kNumericFieldsAlways & flag) != 0 || ((kNumericFieldsForCount12 & flag) != 0 && count < 3)); 1365 } 1366 1367 UBool U_EXPORT2 1368 DateFormatSymbols::isNumericPatternChar(UChar c, int32_t count) { 1369 return isNumericField(getPatternCharIndex(c), count); 1370 } 1371 1372 //------------------------------------------------------ 1373 1374 UnicodeString& 1375 DateFormatSymbols::getLocalPatternChars(UnicodeString& result) const 1376 { 1377 // fastCopyFrom() - see assignArray comments 1378 return result.fastCopyFrom(fLocalPatternChars); 1379 } 1380 1381 //------------------------------------------------------ 1382 1383 void 1384 DateFormatSymbols::setLocalPatternChars(const UnicodeString& newLocalPatternChars) 1385 { 1386 fLocalPatternChars = newLocalPatternChars; 1387 } 1388 1389 //------------------------------------------------------ 1390 1391 static void 1392 initField(UnicodeString **field, int32_t& length, const UResourceBundle *data, UErrorCode &status) { 1393 if (U_SUCCESS(status)) { 1394 int32_t strLen = 0; 1395 length = ures_getSize(data); 1396 *field = newUnicodeStringArray(length); 1397 if (*field) { 1398 for(int32_t i = 0; i<length; i++) { 1399 const UChar *resStr = ures_getStringByIndex(data, i, &strLen, &status); 1400 // setTo() - see assignArray comments 1401 (*(field)+i)->setTo(TRUE, resStr, strLen); 1402 } 1403 } 1404 else { 1405 length = 0; 1406 status = U_MEMORY_ALLOCATION_ERROR; 1407 } 1408 } 1409 } 1410 1411 static void 1412 initField(UnicodeString **field, int32_t& length, const UChar *data, LastResortSize numStr, LastResortSize strLen, UErrorCode &status) { 1413 if (U_SUCCESS(status)) { 1414 length = numStr; 1415 *field = newUnicodeStringArray((size_t)numStr); 1416 if (*field) { 1417 for(int32_t i = 0; i<length; i++) { 1418 // readonly aliases - all "data" strings are constant 1419 // -1 as length for variable-length strings (gLastResortDayNames[0] is empty) 1420 (*(field)+i)->setTo(TRUE, data+(i*((int32_t)strLen)), -1); 1421 } 1422 } 1423 else { 1424 length = 0; 1425 status = U_MEMORY_ALLOCATION_ERROR; 1426 } 1427 } 1428 } 1429 1430 static void 1431 initLeapMonthPattern(UnicodeString *field, int32_t index, const UResourceBundle *data, UErrorCode &status) { 1432 field[index].remove(); 1433 if (U_SUCCESS(status)) { 1434 int32_t strLen = 0; 1435 const UChar *resStr = ures_getStringByKey(data, gNamesLeapTag, &strLen, &status); 1436 if (U_SUCCESS(status)) { 1437 field[index].setTo(TRUE, resStr, strLen); 1438 } 1439 } 1440 status = U_ZERO_ERROR; 1441 } 1442 1443 typedef struct { 1444 const char * usageTypeName; 1445 DateFormatSymbols::ECapitalizationContextUsageType usageTypeEnumValue; 1446 } ContextUsageTypeNameToEnumValue; 1447 1448 static const ContextUsageTypeNameToEnumValue contextUsageTypeMap[] = { 1449 // Entries must be sorted by usageTypeName; entry with NULL name terminates list. 1450 { "day-format-except-narrow", DateFormatSymbols::kCapContextUsageDayFormat }, 1451 { "day-narrow", DateFormatSymbols::kCapContextUsageDayNarrow }, 1452 { "day-standalone-except-narrow", DateFormatSymbols::kCapContextUsageDayStandalone }, 1453 { "era-abbr", DateFormatSymbols::kCapContextUsageEraAbbrev }, 1454 { "era-name", DateFormatSymbols::kCapContextUsageEraWide }, 1455 { "era-narrow", DateFormatSymbols::kCapContextUsageEraNarrow }, 1456 { "metazone-long", DateFormatSymbols::kCapContextUsageMetazoneLong }, 1457 { "metazone-short", DateFormatSymbols::kCapContextUsageMetazoneShort }, 1458 { "month-format-except-narrow", DateFormatSymbols::kCapContextUsageMonthFormat }, 1459 { "month-narrow", DateFormatSymbols::kCapContextUsageMonthNarrow }, 1460 { "month-standalone-except-narrow", DateFormatSymbols::kCapContextUsageMonthStandalone }, 1461 { "zone-long", DateFormatSymbols::kCapContextUsageZoneLong }, 1462 { "zone-short", DateFormatSymbols::kCapContextUsageZoneShort }, 1463 { NULL, (DateFormatSymbols::ECapitalizationContextUsageType)0 }, 1464 }; 1465 1466 void 1467 DateFormatSymbols::initializeData(const Locale& locale, const char *type, UErrorCode& status, UBool useLastResortData) 1468 { 1469 int32_t i; 1470 int32_t len = 0; 1471 const UChar *resStr; 1472 /* In case something goes wrong, initialize all of the data to NULL. */ 1473 fEras = NULL; 1474 fErasCount = 0; 1475 fEraNames = NULL; 1476 fEraNamesCount = 0; 1477 fNarrowEras = NULL; 1478 fNarrowErasCount = 0; 1479 fMonths = NULL; 1480 fMonthsCount=0; 1481 fShortMonths = NULL; 1482 fShortMonthsCount=0; 1483 fNarrowMonths = NULL; 1484 fNarrowMonthsCount=0; 1485 fStandaloneMonths = NULL; 1486 fStandaloneMonthsCount=0; 1487 fStandaloneShortMonths = NULL; 1488 fStandaloneShortMonthsCount=0; 1489 fStandaloneNarrowMonths = NULL; 1490 fStandaloneNarrowMonthsCount=0; 1491 fWeekdays = NULL; 1492 fWeekdaysCount=0; 1493 fShortWeekdays = NULL; 1494 fShortWeekdaysCount=0; 1495 fShorterWeekdays = NULL; 1496 fShorterWeekdaysCount=0; 1497 fNarrowWeekdays = NULL; 1498 fNarrowWeekdaysCount=0; 1499 fStandaloneWeekdays = NULL; 1500 fStandaloneWeekdaysCount=0; 1501 fStandaloneShortWeekdays = NULL; 1502 fStandaloneShortWeekdaysCount=0; 1503 fStandaloneShorterWeekdays = NULL; 1504 fStandaloneShorterWeekdaysCount=0; 1505 fStandaloneNarrowWeekdays = NULL; 1506 fStandaloneNarrowWeekdaysCount=0; 1507 fAmPms = NULL; 1508 fAmPmsCount=0; 1509 fNarrowAmPms = NULL; 1510 fNarrowAmPmsCount=0; 1511 fTimeSeparator.setToBogus(); 1512 fQuarters = NULL; 1513 fQuartersCount = 0; 1514 fShortQuarters = NULL; 1515 fShortQuartersCount = 0; 1516 fStandaloneQuarters = NULL; 1517 fStandaloneQuartersCount = 0; 1518 fStandaloneShortQuarters = NULL; 1519 fStandaloneShortQuartersCount = 0; 1520 fLeapMonthPatterns = NULL; 1521 fLeapMonthPatternsCount = 0; 1522 fShortYearNames = NULL; 1523 fShortYearNamesCount = 0; 1524 fShortZodiacNames = NULL; 1525 fShortZodiacNamesCount = 0; 1526 fZoneStringsRowCount = 0; 1527 fZoneStringsColCount = 0; 1528 fZoneStrings = NULL; 1529 fLocaleZoneStrings = NULL; 1530 uprv_memset(fCapitalization, 0, sizeof(fCapitalization)); 1531 1532 // We need to preserve the requested locale for 1533 // lazy ZoneStringFormat instantiation. ZoneStringFormat 1534 // is region sensitive, thus, bundle locale bundle's locale 1535 // is not sufficient. 1536 fZSFLocale = locale; 1537 1538 if (U_FAILURE(status)) return; 1539 1540 /** 1541 * Retrieve the string arrays we need from the resource bundle file. 1542 * We cast away const here, but that's okay; we won't delete any of 1543 * these. 1544 */ 1545 CalendarData calData(locale, type, status); 1546 1547 // load the first data item 1548 UResourceBundle *erasMain = calData.getByKey(gErasTag, status); 1549 UResourceBundle *eras = ures_getByKeyWithFallback(erasMain, gNamesAbbrTag, NULL, &status); 1550 UErrorCode oldStatus = status; 1551 UResourceBundle *eraNames = ures_getByKeyWithFallback(erasMain, gNamesWideTag, NULL, &status); 1552 if ( status == U_MISSING_RESOURCE_ERROR ) { // Workaround because eras/wide was omitted from CLDR 1.3 1553 status = oldStatus; 1554 eraNames = ures_getByKeyWithFallback(erasMain, gNamesAbbrTag, NULL, &status); 1555 } 1556 // current ICU4J falls back to abbreviated if narrow eras are missing, so we will too 1557 oldStatus = status; 1558 UResourceBundle *narrowEras = ures_getByKeyWithFallback(erasMain, gNamesNarrowTag, NULL, &status); 1559 if ( status == U_MISSING_RESOURCE_ERROR ) { 1560 status = oldStatus; 1561 narrowEras = ures_getByKeyWithFallback(erasMain, gNamesAbbrTag, NULL, &status); 1562 } 1563 1564 UErrorCode tempStatus = U_ZERO_ERROR; 1565 UResourceBundle *monthPatterns = calData.getByKey(gMonthPatternsTag, tempStatus); 1566 if (U_SUCCESS(tempStatus) && monthPatterns != NULL) { 1567 fLeapMonthPatterns = newUnicodeStringArray(kMonthPatternsCount); 1568 if (fLeapMonthPatterns) { 1569 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternFormatWide, calData.getByKey2(gMonthPatternsTag, gNamesWideTag, tempStatus), tempStatus); 1570 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternFormatAbbrev, calData.getByKey2(gMonthPatternsTag, gNamesAbbrTag, tempStatus), tempStatus); 1571 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternFormatNarrow, calData.getByKey2(gMonthPatternsTag, gNamesNarrowTag, tempStatus), tempStatus); 1572 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternStandaloneWide, calData.getByKey3(gMonthPatternsTag, gNamesStandaloneTag, gNamesWideTag, tempStatus), tempStatus); 1573 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternStandaloneAbbrev, calData.getByKey3(gMonthPatternsTag, gNamesStandaloneTag, gNamesAbbrTag, tempStatus), tempStatus); 1574 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternStandaloneNarrow, calData.getByKey3(gMonthPatternsTag, gNamesStandaloneTag, gNamesNarrowTag, tempStatus), tempStatus); 1575 initLeapMonthPattern(fLeapMonthPatterns, kLeapMonthPatternNumeric, calData.getByKey3(gMonthPatternsTag, gNamesNumericTag, gNamesAllTag, tempStatus), tempStatus); 1576 if (U_SUCCESS(tempStatus)) { 1577 // Hack to fix bad C inheritance for dangi monthPatterns (OK in J); this should be handled by aliases in root, but isn't. 1578 // The ordering of the following statements is important. 1579 if (fLeapMonthPatterns[kLeapMonthPatternFormatAbbrev].isEmpty()) { 1580 fLeapMonthPatterns[kLeapMonthPatternFormatAbbrev].setTo(fLeapMonthPatterns[kLeapMonthPatternFormatWide]); 1581 }; 1582 if (fLeapMonthPatterns[kLeapMonthPatternFormatNarrow].isEmpty()) { 1583 fLeapMonthPatterns[kLeapMonthPatternFormatNarrow].setTo(fLeapMonthPatterns[kLeapMonthPatternStandaloneNarrow]); 1584 }; 1585 if (fLeapMonthPatterns[kLeapMonthPatternStandaloneWide].isEmpty()) { 1586 fLeapMonthPatterns[kLeapMonthPatternStandaloneWide].setTo(fLeapMonthPatterns[kLeapMonthPatternFormatWide]); 1587 }; 1588 if (fLeapMonthPatterns[kLeapMonthPatternStandaloneAbbrev].isEmpty()) { 1589 fLeapMonthPatterns[kLeapMonthPatternStandaloneAbbrev].setTo(fLeapMonthPatterns[kLeapMonthPatternFormatAbbrev]); 1590 }; 1591 // end of hack 1592 fLeapMonthPatternsCount = kMonthPatternsCount; 1593 } else { 1594 delete[] fLeapMonthPatterns; 1595 fLeapMonthPatterns = NULL; 1596 } 1597 } 1598 } 1599 1600 tempStatus = U_ZERO_ERROR; 1601 UResourceBundle *cyclicNameSets= calData.getByKey(gCyclicNameSetsTag, tempStatus); 1602 if (U_SUCCESS(tempStatus) && cyclicNameSets != NULL) { 1603 UResourceBundle *nameSetYears = ures_getByKeyWithFallback(cyclicNameSets, gNameSetYearsTag, NULL, &tempStatus); 1604 if (U_SUCCESS(tempStatus)) { 1605 UResourceBundle *nameSetYearsFmt = ures_getByKeyWithFallback(nameSetYears, gNamesFormatTag, NULL, &tempStatus); 1606 if (U_SUCCESS(tempStatus)) { 1607 UResourceBundle *nameSetYearsFmtAbbrev = ures_getByKeyWithFallback(nameSetYearsFmt, gNamesAbbrTag, NULL, &tempStatus); 1608 if (U_SUCCESS(tempStatus)) { 1609 initField(&fShortYearNames, fShortYearNamesCount, nameSetYearsFmtAbbrev, tempStatus); 1610 ures_close(nameSetYearsFmtAbbrev); 1611 } 1612 ures_close(nameSetYearsFmt); 1613 } 1614 ures_close(nameSetYears); 1615 } 1616 UResourceBundle *nameSetZodiacs = ures_getByKeyWithFallback(cyclicNameSets, gNameSetZodiacsTag, NULL, &tempStatus); 1617 if (U_SUCCESS(tempStatus)) { 1618 UResourceBundle *nameSetZodiacsFmt = ures_getByKeyWithFallback(nameSetZodiacs, gNamesFormatTag, NULL, &tempStatus); 1619 if (U_SUCCESS(tempStatus)) { 1620 UResourceBundle *nameSetZodiacsFmtAbbrev = ures_getByKeyWithFallback(nameSetZodiacsFmt, gNamesAbbrTag, NULL, &tempStatus); 1621 if (U_SUCCESS(tempStatus)) { 1622 initField(&fShortZodiacNames, fShortZodiacNamesCount, nameSetZodiacsFmtAbbrev, tempStatus); 1623 ures_close(nameSetZodiacsFmtAbbrev); 1624 } 1625 ures_close(nameSetZodiacsFmt); 1626 } 1627 ures_close(nameSetZodiacs); 1628 } 1629 } 1630 1631 tempStatus = U_ZERO_ERROR; 1632 UResourceBundle *localeBundle = ures_open(NULL, locale.getName(), &tempStatus); 1633 if (U_SUCCESS(tempStatus)) { 1634 UResourceBundle *contextTransforms = ures_getByKeyWithFallback(localeBundle, gContextTransformsTag, NULL, &tempStatus); 1635 if (U_SUCCESS(tempStatus)) { 1636 UResourceBundle *contextTransformUsage; 1637 while ( (contextTransformUsage = ures_getNextResource(contextTransforms, NULL, &tempStatus)) != NULL ) { 1638 const int32_t * intVector = ures_getIntVector(contextTransformUsage, &len, &status); 1639 if (U_SUCCESS(tempStatus) && intVector != NULL && len >= 2) { 1640 const char* usageType = ures_getKey(contextTransformUsage); 1641 if (usageType != NULL) { 1642 const ContextUsageTypeNameToEnumValue * typeMapPtr = contextUsageTypeMap; 1643 int32_t compResult = 0; 1644 // linear search; list is short and we cannot be sure that bsearch is available 1645 while ( typeMapPtr->usageTypeName != NULL && (compResult = uprv_strcmp(usageType, typeMapPtr->usageTypeName)) > 0 ) { 1646 ++typeMapPtr; 1647 } 1648 if (typeMapPtr->usageTypeName != NULL && compResult == 0) { 1649 fCapitalization[typeMapPtr->usageTypeEnumValue][0] = intVector[0]; 1650 fCapitalization[typeMapPtr->usageTypeEnumValue][1] = intVector[1]; 1651 } 1652 } 1653 } 1654 tempStatus = U_ZERO_ERROR; 1655 ures_close(contextTransformUsage); 1656 } 1657 ures_close(contextTransforms); 1658 } 1659 1660 tempStatus = U_ZERO_ERROR; 1661 const LocalPointer<NumberingSystem> numberingSystem( 1662 NumberingSystem::createInstance(locale, tempStatus), tempStatus); 1663 if (U_SUCCESS(tempStatus)) { 1664 // These functions all fail gracefully if passed NULL pointers and 1665 // do nothing unless U_SUCCESS(tempStatus), so it's only necessary 1666 // to check for errors once after all calls are made. 1667 const LocalUResourceBundlePointer numberElementsData(ures_getByKeyWithFallback( 1668 localeBundle, gNumberElementsTag, NULL, &tempStatus)); 1669 const LocalUResourceBundlePointer nsNameData(ures_getByKeyWithFallback( 1670 numberElementsData.getAlias(), numberingSystem->getName(), NULL, &tempStatus)); 1671 const LocalUResourceBundlePointer symbolsData(ures_getByKeyWithFallback( 1672 nsNameData.getAlias(), gSymbolsTag, NULL, &tempStatus)); 1673 fTimeSeparator = ures_getUnicodeStringByKey( 1674 symbolsData.getAlias(), gTimeSeparatorTag, &tempStatus); 1675 if (U_FAILURE(tempStatus)) { 1676 fTimeSeparator.setToBogus(); 1677 } 1678 } 1679 1680 ures_close(localeBundle); 1681 } 1682 1683 if (fTimeSeparator.isBogus()) { 1684 fTimeSeparator.setTo(DateFormatSymbols::DEFAULT_TIME_SEPARATOR); 1685 } 1686 1687 UResourceBundle *weekdaysData = NULL; // Data closed by calData 1688 UResourceBundle *abbrWeekdaysData = NULL; // Data closed by calData 1689 UResourceBundle *shorterWeekdaysData = NULL; // Data closed by calData 1690 UResourceBundle *narrowWeekdaysData = NULL; // Data closed by calData 1691 UResourceBundle *standaloneWeekdaysData = NULL; // Data closed by calData 1692 UResourceBundle *standaloneAbbrWeekdaysData = NULL; // Data closed by calData 1693 UResourceBundle *standaloneShorterWeekdaysData = NULL; // Data closed by calData 1694 UResourceBundle *standaloneNarrowWeekdaysData = NULL; // Data closed by calData 1695 1696 U_LOCALE_BASED(locBased, *this); 1697 if (U_FAILURE(status)) 1698 { 1699 if (useLastResortData) 1700 { 1701 // Handle the case in which there is no resource data present. 1702 // We don't have to generate usable patterns in this situation; 1703 // we just need to produce something that will be semi-intelligible 1704 // in most locales. 1705 1706 status = U_USING_FALLBACK_WARNING; 1707 1708 initField(&fEras, fErasCount, (const UChar *)gLastResortEras, kEraNum, kEraLen, status); 1709 initField(&fEraNames, fEraNamesCount, (const UChar *)gLastResortEras, kEraNum, kEraLen, status); 1710 initField(&fNarrowEras, fNarrowErasCount, (const UChar *)gLastResortEras, kEraNum, kEraLen, status); 1711 initField(&fMonths, fMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); 1712 initField(&fShortMonths, fShortMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); 1713 initField(&fNarrowMonths, fNarrowMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); 1714 initField(&fStandaloneMonths, fStandaloneMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); 1715 initField(&fStandaloneShortMonths, fStandaloneShortMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); 1716 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); 1717 initField(&fWeekdays, fWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1718 initField(&fShortWeekdays, fShortWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1719 initField(&fShorterWeekdays, fShorterWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1720 initField(&fNarrowWeekdays, fNarrowWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1721 initField(&fStandaloneWeekdays, fStandaloneWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1722 initField(&fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1723 initField(&fStandaloneShorterWeekdays, fStandaloneShorterWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1724 initField(&fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1725 initField(&fAmPms, fAmPmsCount, (const UChar *)gLastResortAmPmMarkers, kAmPmNum, kAmPmLen, status); 1726 initField(&fNarrowAmPms, fNarrowAmPmsCount, (const UChar *)gLastResortAmPmMarkers, kAmPmNum, kAmPmLen, status); 1727 initField(&fQuarters, fQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status); 1728 initField(&fShortQuarters, fShortQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status); 1729 initField(&fStandaloneQuarters, fStandaloneQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status); 1730 initField(&fStandaloneShortQuarters, fStandaloneShortQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status); 1731 fLocalPatternChars.setTo(TRUE, gPatternChars, PATTERN_CHARS_LEN); 1732 } 1733 goto cleanup; 1734 } 1735 1736 // if we make it to here, the resource data is cool, and we can get everything out 1737 // of it that we need except for the time-zone and localized-pattern data, which 1738 // are stored in a separate file 1739 locBased.setLocaleIDs(ures_getLocaleByType(eras, ULOC_VALID_LOCALE, &status), 1740 ures_getLocaleByType(eras, ULOC_ACTUAL_LOCALE, &status)); 1741 1742 initField(&fEras, fErasCount, eras, status); 1743 initField(&fEraNames, fEraNamesCount, eraNames, status); 1744 initField(&fNarrowEras, fNarrowErasCount, narrowEras, status); 1745 1746 initField(&fMonths, fMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesWideTag, status), status); 1747 initField(&fShortMonths, fShortMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesAbbrTag, status), status); 1748 1749 initField(&fNarrowMonths, fNarrowMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesNarrowTag, status), status); 1750 if(status == U_MISSING_RESOURCE_ERROR) { 1751 status = U_ZERO_ERROR; 1752 initField(&fNarrowMonths, fNarrowMonthsCount, calData.getByKey3(gMonthNamesTag, gNamesStandaloneTag, gNamesNarrowTag, status), status); 1753 } 1754 if ( status == U_MISSING_RESOURCE_ERROR ) { /* If format/narrow not available, use format/abbreviated */ 1755 status = U_ZERO_ERROR; 1756 initField(&fNarrowMonths, fNarrowMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesAbbrTag, status), status); 1757 } 1758 1759 initField(&fStandaloneMonths, fStandaloneMonthsCount, calData.getByKey3(gMonthNamesTag, gNamesStandaloneTag, gNamesWideTag, status), status); 1760 if ( status == U_MISSING_RESOURCE_ERROR ) { /* If standalone/wide not available, use format/wide */ 1761 status = U_ZERO_ERROR; 1762 initField(&fStandaloneMonths, fStandaloneMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesWideTag, status), status); 1763 } 1764 initField(&fStandaloneShortMonths, fStandaloneShortMonthsCount, calData.getByKey3(gMonthNamesTag, gNamesStandaloneTag, gNamesAbbrTag, status), status); 1765 if ( status == U_MISSING_RESOURCE_ERROR ) { /* If standalone/abbreviated not available, use format/abbreviated */ 1766 status = U_ZERO_ERROR; 1767 initField(&fStandaloneShortMonths, fStandaloneShortMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesAbbrTag, status), status); 1768 } 1769 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, calData.getByKey3(gMonthNamesTag, gNamesStandaloneTag, gNamesNarrowTag, status), status); 1770 if ( status == U_MISSING_RESOURCE_ERROR ) { /* if standalone/narrow not availabe, try format/narrow */ 1771 status = U_ZERO_ERROR; 1772 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesNarrowTag, status), status); 1773 if ( status == U_MISSING_RESOURCE_ERROR ) { /* if still not there, use format/abbreviated */ 1774 status = U_ZERO_ERROR; 1775 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesAbbrTag, status), status); 1776 } 1777 } 1778 initField(&fAmPms, fAmPmsCount, calData.getByKey(gAmPmMarkersTag, status), status); 1779 initField(&fNarrowAmPms, fNarrowAmPmsCount, calData.getByKey(gAmPmMarkersNarrowTag, status), status); 1780 1781 initField(&fQuarters, fQuartersCount, calData.getByKey2(gQuartersTag, gNamesWideTag, status), status); 1782 initField(&fShortQuarters, fShortQuartersCount, calData.getByKey2(gQuartersTag, gNamesAbbrTag, status), status); 1783 1784 initField(&fStandaloneQuarters, fStandaloneQuartersCount, calData.getByKey3(gQuartersTag, gNamesStandaloneTag, gNamesWideTag, status), status); 1785 if(status == U_MISSING_RESOURCE_ERROR) { 1786 status = U_ZERO_ERROR; 1787 initField(&fStandaloneQuarters, fStandaloneQuartersCount, calData.getByKey2(gQuartersTag, gNamesWideTag, status), status); 1788 } 1789 1790 initField(&fStandaloneShortQuarters, fStandaloneShortQuartersCount, calData.getByKey3(gQuartersTag, gNamesStandaloneTag, gNamesAbbrTag, status), status); 1791 if(status == U_MISSING_RESOURCE_ERROR) { 1792 status = U_ZERO_ERROR; 1793 initField(&fStandaloneShortQuarters, fStandaloneShortQuartersCount, calData.getByKey2(gQuartersTag, gNamesAbbrTag, status), status); 1794 } 1795 1796 // ICU 3.8 or later version no longer uses localized date-time pattern characters by default (ticket#5597) 1797 /* 1798 // fastCopyFrom()/setTo() - see assignArray comments 1799 resStr = ures_getStringByKey(fResourceBundle, gLocalPatternCharsTag, &len, &status); 1800 fLocalPatternChars.setTo(TRUE, resStr, len); 1801 // If the locale data does not include new pattern chars, use the defaults 1802 // TODO: Consider making this an error, since this may add conflicting characters. 1803 if (len < PATTERN_CHARS_LEN) { 1804 fLocalPatternChars.append(UnicodeString(TRUE, &gPatternChars[len], PATTERN_CHARS_LEN-len)); 1805 } 1806 */ 1807 fLocalPatternChars.setTo(TRUE, gPatternChars, PATTERN_CHARS_LEN); 1808 1809 // Format wide weekdays -> fWeekdays 1810 // {sfb} fixed to handle 1-based weekdays 1811 weekdaysData = calData.getByKey2(gDayNamesTag, gNamesWideTag, status); 1812 fWeekdaysCount = ures_getSize(weekdaysData); 1813 fWeekdays = new UnicodeString[fWeekdaysCount+1]; 1814 /* pin the blame on system. If we cannot get a chunk of memory .. the system is dying!*/ 1815 if (fWeekdays == NULL) { 1816 status = U_MEMORY_ALLOCATION_ERROR; 1817 goto cleanup; 1818 } 1819 // leave fWeekdays[0] empty 1820 for(i = 0; i<fWeekdaysCount; i++) { 1821 resStr = ures_getStringByIndex(weekdaysData, i, &len, &status); 1822 // setTo() - see assignArray comments 1823 fWeekdays[i+1].setTo(TRUE, resStr, len); 1824 } 1825 fWeekdaysCount++; 1826 1827 // Format abbreviated weekdays -> fShortWeekdays 1828 abbrWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesAbbrTag, status); 1829 fShortWeekdaysCount = ures_getSize(abbrWeekdaysData); 1830 fShortWeekdays = new UnicodeString[fShortWeekdaysCount+1]; 1831 /* test for NULL */ 1832 if (fShortWeekdays == 0) { 1833 status = U_MEMORY_ALLOCATION_ERROR; 1834 goto cleanup; 1835 } 1836 // leave fShortWeekdays[0] empty 1837 for(i = 0; i<fShortWeekdaysCount; i++) { 1838 resStr = ures_getStringByIndex(abbrWeekdaysData, i, &len, &status); 1839 // setTo() - see assignArray comments 1840 fShortWeekdays[i+1].setTo(TRUE, resStr, len); 1841 } 1842 fShortWeekdaysCount++; 1843 1844 // Format short weekdays -> fShorterWeekdays (fall back to abbreviated) 1845 shorterWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesShortTag, status); 1846 if ( status == U_MISSING_RESOURCE_ERROR ) { 1847 status = U_ZERO_ERROR; 1848 shorterWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesAbbrTag, status); 1849 } 1850 fShorterWeekdaysCount = ures_getSize(shorterWeekdaysData); 1851 fShorterWeekdays = new UnicodeString[fShorterWeekdaysCount+1]; 1852 /* test for NULL */ 1853 if (fShorterWeekdays == 0) { 1854 status = U_MEMORY_ALLOCATION_ERROR; 1855 goto cleanup; 1856 } 1857 // leave fShorterWeekdays[0] empty 1858 for(i = 0; i<fShorterWeekdaysCount; i++) { 1859 resStr = ures_getStringByIndex(shorterWeekdaysData, i, &len, &status); 1860 // setTo() - see assignArray comments 1861 fShorterWeekdays[i+1].setTo(TRUE, resStr, len); 1862 } 1863 fShorterWeekdaysCount++; 1864 1865 // Format narrow weekdays -> fNarrowWeekdays 1866 narrowWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesNarrowTag, status); 1867 if(status == U_MISSING_RESOURCE_ERROR) { 1868 status = U_ZERO_ERROR; 1869 narrowWeekdaysData = calData.getByKey3(gDayNamesTag, gNamesStandaloneTag, gNamesNarrowTag, status); 1870 } 1871 if ( status == U_MISSING_RESOURCE_ERROR ) { 1872 status = U_ZERO_ERROR; 1873 narrowWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesAbbrTag, status); 1874 } 1875 fNarrowWeekdaysCount = ures_getSize(narrowWeekdaysData); 1876 fNarrowWeekdays = new UnicodeString[fNarrowWeekdaysCount+1]; 1877 /* test for NULL */ 1878 if (fNarrowWeekdays == 0) { 1879 status = U_MEMORY_ALLOCATION_ERROR; 1880 goto cleanup; 1881 } 1882 // leave fNarrowWeekdays[0] empty 1883 for(i = 0; i<fNarrowWeekdaysCount; i++) { 1884 resStr = ures_getStringByIndex(narrowWeekdaysData, i, &len, &status); 1885 // setTo() - see assignArray comments 1886 fNarrowWeekdays[i+1].setTo(TRUE, resStr, len); 1887 } 1888 fNarrowWeekdaysCount++; 1889 1890 // Stand-alone wide weekdays -> fStandaloneWeekdays 1891 standaloneWeekdaysData = calData.getByKey3(gDayNamesTag, gNamesStandaloneTag, gNamesWideTag, status); 1892 if ( status == U_MISSING_RESOURCE_ERROR ) { 1893 status = U_ZERO_ERROR; 1894 standaloneWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesWideTag, status); 1895 } 1896 fStandaloneWeekdaysCount = ures_getSize(standaloneWeekdaysData); 1897 fStandaloneWeekdays = new UnicodeString[fStandaloneWeekdaysCount+1]; 1898 /* test for NULL */ 1899 if (fStandaloneWeekdays == 0) { 1900 status = U_MEMORY_ALLOCATION_ERROR; 1901 goto cleanup; 1902 } 1903 // leave fStandaloneWeekdays[0] empty 1904 for(i = 0; i<fStandaloneWeekdaysCount; i++) { 1905 resStr = ures_getStringByIndex(standaloneWeekdaysData, i, &len, &status); 1906 // setTo() - see assignArray comments 1907 fStandaloneWeekdays[i+1].setTo(TRUE, resStr, len); 1908 } 1909 fStandaloneWeekdaysCount++; 1910 1911 // Stand-alone abbreviated weekdays -> fStandaloneShortWeekdays 1912 standaloneAbbrWeekdaysData = calData.getByKey3(gDayNamesTag, gNamesStandaloneTag, gNamesAbbrTag, status); 1913 if ( status == U_MISSING_RESOURCE_ERROR ) { 1914 status = U_ZERO_ERROR; 1915 standaloneAbbrWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesAbbrTag, status); 1916 } 1917 fStandaloneShortWeekdaysCount = ures_getSize(standaloneAbbrWeekdaysData); 1918 fStandaloneShortWeekdays = new UnicodeString[fStandaloneShortWeekdaysCount+1]; 1919 /* test for NULL */ 1920 if (fStandaloneShortWeekdays == 0) { 1921 status = U_MEMORY_ALLOCATION_ERROR; 1922 goto cleanup; 1923 } 1924 // leave fStandaloneShortWeekdays[0] empty 1925 for(i = 0; i<fStandaloneShortWeekdaysCount; i++) { 1926 resStr = ures_getStringByIndex(standaloneAbbrWeekdaysData, i, &len, &status); 1927 // setTo() - see assignArray comments 1928 fStandaloneShortWeekdays[i+1].setTo(TRUE, resStr, len); 1929 } 1930 fStandaloneShortWeekdaysCount++; 1931 1932 // Stand-alone short weekdays -> fStandaloneShorterWeekdays (fall back to format abbreviated) 1933 standaloneShorterWeekdaysData = calData.getByKey3(gDayNamesTag, gNamesStandaloneTag, gNamesShortTag, status); 1934 if ( status == U_MISSING_RESOURCE_ERROR ) { 1935 status = U_ZERO_ERROR; 1936 standaloneShorterWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesAbbrTag, status); 1937 } 1938 fStandaloneShorterWeekdaysCount = ures_getSize(standaloneShorterWeekdaysData); 1939 fStandaloneShorterWeekdays = new UnicodeString[fStandaloneShorterWeekdaysCount+1]; 1940 /* test for NULL */ 1941 if (fStandaloneShorterWeekdays == 0) { 1942 status = U_MEMORY_ALLOCATION_ERROR; 1943 goto cleanup; 1944 } 1945 // leave fStandaloneShorterWeekdays[0] empty 1946 for(i = 0; i<fStandaloneShorterWeekdaysCount; i++) { 1947 resStr = ures_getStringByIndex(standaloneShorterWeekdaysData, i, &len, &status); 1948 // setTo() - see assignArray comments 1949 fStandaloneShorterWeekdays[i+1].setTo(TRUE, resStr, len); 1950 } 1951 fStandaloneShorterWeekdaysCount++; 1952 1953 // Stand-alone narrow weekdays -> fStandaloneNarrowWeekdays 1954 standaloneNarrowWeekdaysData = calData.getByKey3(gDayNamesTag, gNamesStandaloneTag, gNamesNarrowTag, status); 1955 if ( status == U_MISSING_RESOURCE_ERROR ) { 1956 status = U_ZERO_ERROR; 1957 standaloneNarrowWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesNarrowTag, status); 1958 if ( status == U_MISSING_RESOURCE_ERROR ) { 1959 status = U_ZERO_ERROR; 1960 standaloneNarrowWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesAbbrTag, status); 1961 } 1962 } 1963 fStandaloneNarrowWeekdaysCount = ures_getSize(standaloneNarrowWeekdaysData); 1964 fStandaloneNarrowWeekdays = new UnicodeString[fStandaloneNarrowWeekdaysCount+1]; 1965 /* test for NULL */ 1966 if (fStandaloneNarrowWeekdays == 0) { 1967 status = U_MEMORY_ALLOCATION_ERROR; 1968 goto cleanup; 1969 } 1970 // leave fStandaloneNarrowWeekdays[0] empty 1971 for(i = 0; i<fStandaloneNarrowWeekdaysCount; i++) { 1972 resStr = ures_getStringByIndex(standaloneNarrowWeekdaysData, i, &len, &status); 1973 // setTo() - see assignArray comments 1974 fStandaloneNarrowWeekdays[i+1].setTo(TRUE, resStr, len); 1975 } 1976 fStandaloneNarrowWeekdaysCount++; 1977 1978 cleanup: 1979 ures_close(eras); 1980 ures_close(eraNames); 1981 ures_close(narrowEras); 1982 } 1983 1984 Locale 1985 DateFormatSymbols::getLocale(ULocDataLocaleType type, UErrorCode& status) const { 1986 U_LOCALE_BASED(locBased, *this); 1987 return locBased.getLocale(type, status); 1988 } 1989 1990 U_NAMESPACE_END 1991 1992 #endif /* #if !UCONFIG_NO_FORMATTING */ 1993 1994 //eof 1995
