1 /* 2 ******************************************************************************* 3 * Copyright (C) 1997-2009, 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/dtfmtsym.h" 27 #include "unicode/smpdtfmt.h" 28 #include "unicode/msgfmt.h" 29 #include "cpputils.h" 30 #include "ucln_in.h" 31 #include "umutex.h" 32 #include "cmemory.h" 33 #include "cstring.h" 34 #include "locbased.h" 35 #include "gregoimp.h" 36 #include "hash.h" 37 #include "uresimp.h" 38 #include "zstrfmt.h" 39 #include "ureslocs.h" 40 41 // ***************************************************************************** 42 // class DateFormatSymbols 43 // ***************************************************************************** 44 45 /** 46 * These are static arrays we use only in the case where we have no 47 * resource data. 48 */ 49 50 #define PATTERN_CHARS_LEN 30 51 52 /** 53 * Unlocalized date-time pattern characters. For example: 'y', 'd', etc. All 54 * locales use the same these unlocalized pattern characters. 55 */ 56 static const UChar gPatternChars[] = { 57 // GyMdkHmsSEDFwWahKzYeugAZvcLQqV 58 0x47, 0x79, 0x4D, 0x64, 0x6B, 0x48, 0x6D, 0x73, 0x53, 0x45, 59 0x44, 0x46, 0x77, 0x57, 0x61, 0x68, 0x4B, 0x7A, 0x59, 0x65, 60 0x75, 0x67, 0x41, 0x5A, 0x76, 0x63, 0x4c, 0x51, 0x71, 0x56, 0 61 }; 62 63 /* length of an array */ 64 #define ARRAY_LENGTH(array) (sizeof(array)/sizeof(array[0])) 65 66 //------------------------------------------------------ 67 // Strings of last resort. These are only used if we have no resource 68 // files. They aren't designed for actual use, just for backup. 69 70 // These are the month names and abbreviations of last resort. 71 static const UChar gLastResortMonthNames[13][3] = 72 { 73 {0x0030, 0x0031, 0x0000}, /* "01" */ 74 {0x0030, 0x0032, 0x0000}, /* "02" */ 75 {0x0030, 0x0033, 0x0000}, /* "03" */ 76 {0x0030, 0x0034, 0x0000}, /* "04" */ 77 {0x0030, 0x0035, 0x0000}, /* "05" */ 78 {0x0030, 0x0036, 0x0000}, /* "06" */ 79 {0x0030, 0x0037, 0x0000}, /* "07" */ 80 {0x0030, 0x0038, 0x0000}, /* "08" */ 81 {0x0030, 0x0039, 0x0000}, /* "09" */ 82 {0x0031, 0x0030, 0x0000}, /* "10" */ 83 {0x0031, 0x0031, 0x0000}, /* "11" */ 84 {0x0031, 0x0032, 0x0000}, /* "12" */ 85 {0x0031, 0x0033, 0x0000} /* "13" */ 86 }; 87 88 // These are the weekday names and abbreviations of last resort. 89 static const UChar gLastResortDayNames[8][2] = 90 { 91 {0x0030, 0x0000}, /* "0" */ 92 {0x0031, 0x0000}, /* "1" */ 93 {0x0032, 0x0000}, /* "2" */ 94 {0x0033, 0x0000}, /* "3" */ 95 {0x0034, 0x0000}, /* "4" */ 96 {0x0035, 0x0000}, /* "5" */ 97 {0x0036, 0x0000}, /* "6" */ 98 {0x0037, 0x0000} /* "7" */ 99 }; 100 101 // These are the quarter names and abbreviations of last resort. 102 static const UChar gLastResortQuarters[4][2] = 103 { 104 {0x0031, 0x0000}, /* "1" */ 105 {0x0032, 0x0000}, /* "2" */ 106 {0x0033, 0x0000}, /* "3" */ 107 {0x0034, 0x0000}, /* "4" */ 108 }; 109 110 // These are the am/pm and BC/AD markers of last resort. 111 static const UChar gLastResortAmPmMarkers[2][3] = 112 { 113 {0x0041, 0x004D, 0x0000}, /* "AM" */ 114 {0x0050, 0x004D, 0x0000} /* "PM" */ 115 }; 116 117 static const UChar gLastResortEras[2][3] = 118 { 119 {0x0042, 0x0043, 0x0000}, /* "BC" */ 120 {0x0041, 0x0044, 0x0000} /* "AD" */ 121 }; 122 123 124 // These are the zone strings of last resort. 125 static const UChar gLastResortZoneStrings[7][4] = 126 { 127 {0x0047, 0x004D, 0x0054, 0x0000}, /* "GMT" */ 128 {0x0047, 0x004D, 0x0054, 0x0000}, /* "GMT" */ 129 {0x0047, 0x004D, 0x0054, 0x0000}, /* "GMT" */ 130 {0x0047, 0x004D, 0x0054, 0x0000}, /* "GMT" */ 131 {0x0047, 0x004D, 0x0054, 0x0000}, /* "GMT" */ 132 {0x0047, 0x004D, 0x0054, 0x0000}, /* "GMT" */ 133 {0x0047, 0x004D, 0x0054, 0x0000} /* "GMT" */ 134 }; 135 136 static const UChar gLastResortGmtFormat[] = 137 {0x0047, 0x004D, 0x0054, 0x007B, 0x0030, 0x007D, 0x0000}; /* GMT{0} */ 138 139 static const UChar gLastResortGmtHourFormats[4][10] = 140 { 141 {0x002D, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0x0000}, /* -HH:mm:ss */ 142 {0x002D, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x0000, 0x0000, 0x0000, 0x0000}, /* -HH:mm */ 143 {0x002B, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0x0000}, /* +HH:mm:ss */ 144 {0x002B, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x0000, 0x0000, 0x0000, 0x0000} /* +HH:mm */ 145 }; 146 147 /* Sizes for the last resort string arrays */ 148 typedef enum LastResortSize { 149 kMonthNum = 13, 150 kMonthLen = 3, 151 152 kDayNum = 8, 153 kDayLen = 2, 154 155 kAmPmNum = 2, 156 kAmPmLen = 3, 157 158 kQuarterNum = 4, 159 kQuarterLen = 2, 160 161 kEraNum = 2, 162 kEraLen = 3, 163 164 kZoneNum = 5, 165 kZoneLen = 4, 166 167 kGmtHourNum = 4, 168 kGmtHourLen = 10 169 } LastResortSize; 170 171 U_NAMESPACE_BEGIN 172 173 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateFormatSymbols) 174 175 #define kSUPPLEMENTAL "supplementalData" 176 177 /** 178 * These are the tags we expect to see in normal resource bundle files associated 179 * with a locale and calendar 180 */ 181 static const char gErasTag[]="eras"; 182 static const char gMonthNamesTag[]="monthNames"; 183 static const char gDayNamesTag[]="dayNames"; 184 static const char gNamesWideTag[]="wide"; 185 static const char gNamesAbbrTag[]="abbreviated"; 186 static const char gNamesNarrowTag[]="narrow"; 187 static const char gNamesStandaloneTag[]="stand-alone"; 188 static const char gAmPmMarkersTag[]="AmPmMarkers"; 189 static const char gQuartersTag[]="quarters"; 190 191 static const char gZoneStringsTag[]="zoneStrings"; 192 static const char gGmtFormatTag[]="gmtFormat"; 193 static const char gHourFormatTag[]="hourFormat"; 194 195 static const char gLocalPatternCharsTag[]="localPatternChars"; 196 197 static UMTX LOCK; 198 199 /** 200 * Jitterbug 2974: MSVC has a bug whereby new X[0] behaves badly. 201 * Work around this. 202 */ 203 static inline UnicodeString* newUnicodeStringArray(size_t count) { 204 return new UnicodeString[count ? count : 1]; 205 } 206 207 //------------------------------------------------------ 208 209 DateFormatSymbols::DateFormatSymbols(const Locale& locale, 210 UErrorCode& status) 211 : UObject() 212 { 213 initializeData(locale, NULL, status); 214 } 215 216 DateFormatSymbols::DateFormatSymbols(UErrorCode& status) 217 : UObject() 218 { 219 initializeData(Locale::getDefault(), NULL, status, TRUE); 220 } 221 222 223 DateFormatSymbols::DateFormatSymbols(const Locale& locale, 224 const char *type, 225 UErrorCode& status) 226 : UObject() 227 { 228 initializeData(locale, type, status); 229 } 230 231 DateFormatSymbols::DateFormatSymbols(const char *type, UErrorCode& status) 232 : UObject() 233 { 234 initializeData(Locale::getDefault(), type, status, TRUE); 235 } 236 237 DateFormatSymbols::DateFormatSymbols(const DateFormatSymbols& other) 238 : UObject(other) 239 { 240 copyData(other); 241 } 242 243 void 244 DateFormatSymbols::assignArray(UnicodeString*& dstArray, 245 int32_t& dstCount, 246 const UnicodeString* srcArray, 247 int32_t srcCount) 248 { 249 // assignArray() is only called by copyData(), which in turn implements the 250 // copy constructor and the assignment operator. 251 // All strings in a DateFormatSymbols object are created in one of the following 252 // three ways that all allow to safely use UnicodeString::fastCopyFrom(): 253 // - readonly-aliases from resource bundles 254 // - readonly-aliases or allocated strings from constants 255 // - safely cloned strings (with owned buffers) from setXYZ() functions 256 // 257 // Note that this is true for as long as DateFormatSymbols can be constructed 258 // only from a locale bundle or set via the cloning API, 259 // *and* for as long as all the strings are in *private* fields, preventing 260 // a subclass from creating these strings in an "unsafe" way (with respect to fastCopyFrom()). 261 dstCount = srcCount; 262 dstArray = newUnicodeStringArray(srcCount); 263 if(dstArray != NULL) { 264 int32_t i; 265 for(i=0; i<srcCount; ++i) { 266 dstArray[i].fastCopyFrom(srcArray[i]); 267 } 268 } 269 } 270 271 /** 272 * Create a copy, in fZoneStrings, of the given zone strings array. The 273 * member variables fZoneStringsRowCount and fZoneStringsColCount should 274 * be set already by the caller. 275 */ 276 void 277 DateFormatSymbols::createZoneStrings(const UnicodeString *const * otherStrings) 278 { 279 int32_t row, col; 280 UBool failed = FALSE; 281 282 fZoneStrings = (UnicodeString **)uprv_malloc(fZoneStringsRowCount * sizeof(UnicodeString *)); 283 if (fZoneStrings != NULL) { 284 for (row=0; row<fZoneStringsRowCount; ++row) 285 { 286 fZoneStrings[row] = newUnicodeStringArray(fZoneStringsColCount); 287 if (fZoneStrings[row] == NULL) { 288 failed = TRUE; 289 break; 290 } 291 for (col=0; col<fZoneStringsColCount; ++col) { 292 // fastCopyFrom() - see assignArray comments 293 fZoneStrings[row][col].fastCopyFrom(otherStrings[row][col]); 294 } 295 } 296 } 297 // If memory allocation failed, roll back and delete fZoneStrings 298 if (failed) { 299 for (int i = row; i >= 0; i--) { 300 delete[] fZoneStrings[i]; 301 } 302 uprv_free(fZoneStrings); 303 fZoneStrings = NULL; 304 } 305 } 306 307 /** 308 * Copy all of the other's data to this. 309 */ 310 void 311 DateFormatSymbols::copyData(const DateFormatSymbols& other) { 312 assignArray(fEras, fErasCount, other.fEras, other.fErasCount); 313 assignArray(fEraNames, fEraNamesCount, other.fEraNames, other.fEraNamesCount); 314 assignArray(fNarrowEras, fNarrowErasCount, other.fNarrowEras, other.fNarrowErasCount); 315 assignArray(fMonths, fMonthsCount, other.fMonths, other.fMonthsCount); 316 assignArray(fShortMonths, fShortMonthsCount, other.fShortMonths, other.fShortMonthsCount); 317 assignArray(fNarrowMonths, fNarrowMonthsCount, other.fNarrowMonths, other.fNarrowMonthsCount); 318 assignArray(fStandaloneMonths, fStandaloneMonthsCount, other.fStandaloneMonths, other.fStandaloneMonthsCount); 319 assignArray(fStandaloneShortMonths, fStandaloneShortMonthsCount, other.fStandaloneShortMonths, other.fStandaloneShortMonthsCount); 320 assignArray(fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, other.fStandaloneNarrowMonths, other.fStandaloneNarrowMonthsCount); 321 assignArray(fWeekdays, fWeekdaysCount, other.fWeekdays, other.fWeekdaysCount); 322 assignArray(fShortWeekdays, fShortWeekdaysCount, other.fShortWeekdays, other.fShortWeekdaysCount); 323 assignArray(fNarrowWeekdays, fNarrowWeekdaysCount, other.fNarrowWeekdays, other.fNarrowWeekdaysCount); 324 assignArray(fStandaloneWeekdays, fStandaloneWeekdaysCount, other.fStandaloneWeekdays, other.fStandaloneWeekdaysCount); 325 assignArray(fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount, other.fStandaloneShortWeekdays, other.fStandaloneShortWeekdaysCount); 326 assignArray(fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, other.fStandaloneNarrowWeekdays, other.fStandaloneNarrowWeekdaysCount); 327 assignArray(fAmPms, fAmPmsCount, other.fAmPms, other.fAmPmsCount); 328 assignArray(fQuarters, fQuartersCount, other.fQuarters, other.fQuartersCount); 329 assignArray(fShortQuarters, fShortQuartersCount, other.fShortQuarters, other.fShortQuartersCount); 330 assignArray(fStandaloneQuarters, fStandaloneQuartersCount, other.fStandaloneQuarters, other.fStandaloneQuartersCount); 331 assignArray(fStandaloneShortQuarters, fStandaloneShortQuartersCount, other.fStandaloneShortQuarters, other.fStandaloneShortQuartersCount); 332 fGmtFormat = other.fGmtFormat; 333 assignArray(fGmtHourFormats, fGmtHourFormatsCount, other.fGmtHourFormats, other.fGmtHourFormatsCount); 334 335 if (other.fZoneStrings != NULL) { 336 fZoneStringsColCount = other.fZoneStringsColCount; 337 fZoneStringsRowCount = other.fZoneStringsRowCount; 338 createZoneStrings((const UnicodeString**)other.fZoneStrings); 339 340 } else { 341 fZoneStrings = NULL; 342 fZoneStringsColCount = 0; 343 fZoneStringsRowCount = 0; 344 } 345 fZSFLocale = other.fZSFLocale; 346 // Other zone strings data is created on demand 347 fZoneStringFormat = NULL; 348 fLocaleZoneStrings = NULL; 349 fZSFCachePtr = NULL; 350 fZSFLocal = NULL; 351 352 // fastCopyFrom() - see assignArray comments 353 fLocalPatternChars.fastCopyFrom(other.fLocalPatternChars); 354 } 355 356 /** 357 * Assignment operator. 358 */ 359 DateFormatSymbols& DateFormatSymbols::operator=(const DateFormatSymbols& other) 360 { 361 dispose(); 362 copyData(other); 363 364 return *this; 365 } 366 367 DateFormatSymbols::~DateFormatSymbols() 368 { 369 dispose(); 370 } 371 372 void DateFormatSymbols::dispose() 373 { 374 if (fEras) delete[] fEras; 375 if (fEraNames) delete[] fEraNames; 376 if (fNarrowEras) delete[] fNarrowEras; 377 if (fMonths) delete[] fMonths; 378 if (fShortMonths) delete[] fShortMonths; 379 if (fNarrowMonths) delete[] fNarrowMonths; 380 if (fStandaloneMonths) delete[] fStandaloneMonths; 381 if (fStandaloneShortMonths) delete[] fStandaloneShortMonths; 382 if (fStandaloneNarrowMonths) delete[] fStandaloneNarrowMonths; 383 if (fWeekdays) delete[] fWeekdays; 384 if (fShortWeekdays) delete[] fShortWeekdays; 385 if (fNarrowWeekdays) delete[] fNarrowWeekdays; 386 if (fStandaloneWeekdays) delete[] fStandaloneWeekdays; 387 if (fStandaloneShortWeekdays) delete[] fStandaloneShortWeekdays; 388 if (fStandaloneNarrowWeekdays) delete[] fStandaloneNarrowWeekdays; 389 if (fAmPms) delete[] fAmPms; 390 if (fQuarters) delete[] fQuarters; 391 if (fShortQuarters) delete[] fShortQuarters; 392 if (fStandaloneQuarters) delete[] fStandaloneQuarters; 393 if (fStandaloneShortQuarters) delete[] fStandaloneShortQuarters; 394 if (fGmtHourFormats) delete[] fGmtHourFormats; 395 396 disposeZoneStrings(); 397 } 398 399 void DateFormatSymbols::disposeZoneStrings() 400 { 401 if (fZoneStrings) { 402 for (int32_t row = 0; row < fZoneStringsRowCount; ++row) { 403 delete[] fZoneStrings[row]; 404 } 405 uprv_free(fZoneStrings); 406 } 407 if (fLocaleZoneStrings) { 408 for (int32_t row = 0; row < fZoneStringsRowCount; ++row) { 409 delete[] fLocaleZoneStrings[row]; 410 } 411 uprv_free(fLocaleZoneStrings); 412 } 413 if (fZSFLocal) { 414 delete fZSFLocal; 415 } 416 if (fZSFCachePtr) { 417 delete fZSFCachePtr; 418 } 419 420 fZoneStrings = NULL; 421 fLocaleZoneStrings = NULL; 422 fZoneStringsRowCount = 0; 423 fZoneStringsColCount = 0; 424 425 fZoneStringFormat = NULL; 426 fZSFLocal = NULL; 427 fZSFCachePtr = NULL; 428 } 429 430 UBool 431 DateFormatSymbols::arrayCompare(const UnicodeString* array1, 432 const UnicodeString* array2, 433 int32_t count) 434 { 435 if (array1 == array2) return TRUE; 436 while (count>0) 437 { 438 --count; 439 if (array1[count] != array2[count]) return FALSE; 440 } 441 return TRUE; 442 } 443 444 UBool 445 DateFormatSymbols::operator==(const DateFormatSymbols& other) const 446 { 447 // First do cheap comparisons 448 if (this == &other) { 449 return TRUE; 450 } 451 if (fErasCount == other.fErasCount && 452 fEraNamesCount == other.fEraNamesCount && 453 fNarrowErasCount == other.fNarrowErasCount && 454 fMonthsCount == other.fMonthsCount && 455 fShortMonthsCount == other.fShortMonthsCount && 456 fNarrowMonthsCount == other.fNarrowMonthsCount && 457 fStandaloneMonthsCount == other.fStandaloneMonthsCount && 458 fStandaloneShortMonthsCount == other.fStandaloneShortMonthsCount && 459 fStandaloneNarrowMonthsCount == other.fStandaloneNarrowMonthsCount && 460 fWeekdaysCount == other.fWeekdaysCount && 461 fShortWeekdaysCount == other.fShortWeekdaysCount && 462 fNarrowWeekdaysCount == other.fNarrowWeekdaysCount && 463 fStandaloneWeekdaysCount == other.fStandaloneWeekdaysCount && 464 fStandaloneShortWeekdaysCount == other.fStandaloneShortWeekdaysCount && 465 fStandaloneNarrowWeekdaysCount == other.fStandaloneNarrowWeekdaysCount && 466 fAmPmsCount == other.fAmPmsCount && 467 fQuartersCount == other.fQuartersCount && 468 fShortQuartersCount == other.fShortQuartersCount && 469 fStandaloneQuartersCount == other.fStandaloneQuartersCount && 470 fStandaloneShortQuartersCount == other.fStandaloneShortQuartersCount && 471 fGmtHourFormatsCount == other.fGmtHourFormatsCount && 472 fGmtFormat == other.fGmtFormat) 473 { 474 // Now compare the arrays themselves 475 if (arrayCompare(fEras, other.fEras, fErasCount) && 476 arrayCompare(fEraNames, other.fEraNames, fEraNamesCount) && 477 arrayCompare(fNarrowEras, other.fNarrowEras, fNarrowErasCount) && 478 arrayCompare(fMonths, other.fMonths, fMonthsCount) && 479 arrayCompare(fShortMonths, other.fShortMonths, fShortMonthsCount) && 480 arrayCompare(fNarrowMonths, other.fNarrowMonths, fNarrowMonthsCount) && 481 arrayCompare(fStandaloneMonths, other.fStandaloneMonths, fStandaloneMonthsCount) && 482 arrayCompare(fStandaloneShortMonths, other.fStandaloneShortMonths, fStandaloneShortMonthsCount) && 483 arrayCompare(fStandaloneNarrowMonths, other.fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount) && 484 arrayCompare(fWeekdays, other.fWeekdays, fWeekdaysCount) && 485 arrayCompare(fShortWeekdays, other.fShortWeekdays, fShortWeekdaysCount) && 486 arrayCompare(fNarrowWeekdays, other.fNarrowWeekdays, fNarrowWeekdaysCount) && 487 arrayCompare(fStandaloneWeekdays, other.fStandaloneWeekdays, fStandaloneWeekdaysCount) && 488 arrayCompare(fStandaloneShortWeekdays, other.fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount) && 489 arrayCompare(fStandaloneNarrowWeekdays, other.fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount) && 490 arrayCompare(fAmPms, other.fAmPms, fAmPmsCount) && 491 arrayCompare(fQuarters, other.fQuarters, fQuartersCount) && 492 arrayCompare(fShortQuarters, other.fShortQuarters, fShortQuartersCount) && 493 arrayCompare(fStandaloneQuarters, other.fStandaloneQuarters, fStandaloneQuartersCount) && 494 arrayCompare(fStandaloneShortQuarters, other.fStandaloneShortQuarters, fStandaloneShortQuartersCount) && 495 arrayCompare(fGmtHourFormats, other.fGmtHourFormats, fGmtHourFormatsCount)) 496 { 497 // Compare the contents of fZoneStrings 498 if (fZoneStrings == NULL && other.fZoneStrings == NULL) { 499 if (fZSFLocale == other.fZSFLocale) { 500 return TRUE; 501 } 502 } else if (fZoneStrings != NULL && other.fZoneStrings != NULL) { 503 if (fZoneStringsRowCount == other.fZoneStringsRowCount 504 && fZoneStringsColCount == other.fZoneStringsColCount) { 505 UBool cmpres = TRUE; 506 for (int32_t i = 0; (i < fZoneStringsRowCount) && cmpres; i++) { 507 cmpres = arrayCompare(fZoneStrings[i], other.fZoneStrings[i], fZoneStringsColCount); 508 } 509 return cmpres; 510 } 511 } 512 return FALSE; 513 } 514 } 515 return FALSE; 516 } 517 518 //------------------------------------------------------ 519 520 const UnicodeString* 521 DateFormatSymbols::getEras(int32_t &count) const 522 { 523 count = fErasCount; 524 return fEras; 525 } 526 527 const UnicodeString* 528 DateFormatSymbols::getEraNames(int32_t &count) const 529 { 530 count = fEraNamesCount; 531 return fEraNames; 532 } 533 534 const UnicodeString* 535 DateFormatSymbols::getNarrowEras(int32_t &count) const 536 { 537 count = fNarrowErasCount; 538 return fNarrowEras; 539 } 540 541 const UnicodeString* 542 DateFormatSymbols::getMonths(int32_t &count) const 543 { 544 count = fMonthsCount; 545 return fMonths; 546 } 547 548 const UnicodeString* 549 DateFormatSymbols::getShortMonths(int32_t &count) const 550 { 551 count = fShortMonthsCount; 552 return fShortMonths; 553 } 554 555 const UnicodeString* 556 DateFormatSymbols::getMonths(int32_t &count, DtContextType context, DtWidthType width ) const 557 { 558 UnicodeString *returnValue = NULL; 559 560 switch (context) { 561 case FORMAT : 562 switch(width) { 563 case WIDE : 564 count = fMonthsCount; 565 returnValue = fMonths; 566 break; 567 case ABBREVIATED : 568 count = fShortMonthsCount; 569 returnValue = fShortMonths; 570 break; 571 case NARROW : 572 count = fNarrowMonthsCount; 573 returnValue = fNarrowMonths; 574 break; 575 case DT_WIDTH_COUNT : 576 break; 577 } 578 break; 579 case STANDALONE : 580 switch(width) { 581 case WIDE : 582 count = fStandaloneMonthsCount; 583 returnValue = fStandaloneMonths; 584 break; 585 case ABBREVIATED : 586 count = fStandaloneShortMonthsCount; 587 returnValue = fStandaloneShortMonths; 588 break; 589 case NARROW : 590 count = fStandaloneNarrowMonthsCount; 591 returnValue = fStandaloneNarrowMonths; 592 break; 593 case DT_WIDTH_COUNT : 594 break; 595 } 596 break; 597 case DT_CONTEXT_COUNT : 598 break; 599 } 600 return returnValue; 601 } 602 603 const UnicodeString* 604 DateFormatSymbols::getWeekdays(int32_t &count) const 605 { 606 count = fWeekdaysCount; 607 return fWeekdays; 608 } 609 610 const UnicodeString* 611 DateFormatSymbols::getShortWeekdays(int32_t &count) const 612 { 613 count = fShortWeekdaysCount; 614 return fShortWeekdays; 615 } 616 617 const UnicodeString* 618 DateFormatSymbols::getWeekdays(int32_t &count, DtContextType context, DtWidthType width) const 619 { 620 UnicodeString *returnValue = NULL; 621 switch (context) { 622 case FORMAT : 623 switch(width) { 624 case WIDE : 625 count = fWeekdaysCount; 626 returnValue = fWeekdays; 627 break; 628 case ABBREVIATED : 629 count = fShortWeekdaysCount; 630 returnValue = fShortWeekdays; 631 break; 632 case NARROW : 633 count = fNarrowWeekdaysCount; 634 returnValue = fNarrowWeekdays; 635 break; 636 case DT_WIDTH_COUNT : 637 break; 638 } 639 break; 640 case STANDALONE : 641 switch(width) { 642 case WIDE : 643 count = fStandaloneWeekdaysCount; 644 returnValue = fStandaloneWeekdays; 645 break; 646 case ABBREVIATED : 647 count = fStandaloneShortWeekdaysCount; 648 returnValue = fStandaloneShortWeekdays; 649 break; 650 case NARROW : 651 count = fStandaloneNarrowWeekdaysCount; 652 returnValue = fStandaloneNarrowWeekdays; 653 break; 654 case DT_WIDTH_COUNT : 655 break; 656 } 657 break; 658 case DT_CONTEXT_COUNT : 659 break; 660 } 661 return returnValue; 662 } 663 664 const UnicodeString* 665 DateFormatSymbols::getQuarters(int32_t &count, DtContextType context, DtWidthType width ) const 666 { 667 UnicodeString *returnValue = NULL; 668 669 switch (context) { 670 case FORMAT : 671 switch(width) { 672 case WIDE : 673 count = fQuartersCount; 674 returnValue = fQuarters; 675 break; 676 case ABBREVIATED : 677 count = fShortQuartersCount; 678 returnValue = fShortQuarters; 679 break; 680 case NARROW : 681 count = 0; 682 returnValue = NULL; 683 break; 684 case DT_WIDTH_COUNT : 685 break; 686 } 687 break; 688 case STANDALONE : 689 switch(width) { 690 case WIDE : 691 count = fStandaloneQuartersCount; 692 returnValue = fStandaloneQuarters; 693 break; 694 case ABBREVIATED : 695 count = fStandaloneShortQuartersCount; 696 returnValue = fStandaloneShortQuarters; 697 break; 698 case NARROW : 699 count = 0; 700 returnValue = NULL; 701 break; 702 case DT_WIDTH_COUNT : 703 break; 704 } 705 break; 706 case DT_CONTEXT_COUNT : 707 break; 708 } 709 return returnValue; 710 } 711 712 const UnicodeString* 713 DateFormatSymbols::getAmPmStrings(int32_t &count) const 714 { 715 count = fAmPmsCount; 716 return fAmPms; 717 } 718 719 //------------------------------------------------------ 720 721 void 722 DateFormatSymbols::setEras(const UnicodeString* erasArray, int32_t count) 723 { 724 // delete the old list if we own it 725 if (fEras) 726 delete[] fEras; 727 728 // we always own the new list, which we create here (we duplicate rather 729 // than adopting the list passed in) 730 fEras = newUnicodeStringArray(count); 731 uprv_arrayCopy(erasArray,fEras, count); 732 fErasCount = count; 733 } 734 735 void 736 DateFormatSymbols::setEraNames(const UnicodeString* eraNamesArray, int32_t count) 737 { 738 // delete the old list if we own it 739 if (fEraNames) 740 delete[] fEraNames; 741 742 // we always own the new list, which we create here (we duplicate rather 743 // than adopting the list passed in) 744 fEraNames = newUnicodeStringArray(count); 745 uprv_arrayCopy(eraNamesArray,fEraNames, count); 746 fEraNamesCount = count; 747 } 748 749 void 750 DateFormatSymbols::setNarrowEras(const UnicodeString* narrowErasArray, int32_t count) 751 { 752 // delete the old list if we own it 753 if (fNarrowEras) 754 delete[] fNarrowEras; 755 756 // we always own the new list, which we create here (we duplicate rather 757 // than adopting the list passed in) 758 fNarrowEras = newUnicodeStringArray(count); 759 uprv_arrayCopy(narrowErasArray,fNarrowEras, count); 760 fNarrowErasCount = count; 761 } 762 763 void 764 DateFormatSymbols::setMonths(const UnicodeString* monthsArray, int32_t count) 765 { 766 // delete the old list if we own it 767 if (fMonths) 768 delete[] fMonths; 769 770 // we always own the new list, which we create here (we duplicate rather 771 // than adopting the list passed in) 772 fMonths = newUnicodeStringArray(count); 773 uprv_arrayCopy( monthsArray,fMonths,count); 774 fMonthsCount = count; 775 } 776 777 void 778 DateFormatSymbols::setShortMonths(const UnicodeString* shortMonthsArray, int32_t count) 779 { 780 // delete the old list if we own it 781 if (fShortMonths) 782 delete[] fShortMonths; 783 784 // we always own the new list, which we create here (we duplicate rather 785 // than adopting the list passed in) 786 fShortMonths = newUnicodeStringArray(count); 787 uprv_arrayCopy(shortMonthsArray,fShortMonths, count); 788 fShortMonthsCount = count; 789 } 790 791 void 792 DateFormatSymbols::setMonths(const UnicodeString* monthsArray, int32_t count, DtContextType context, DtWidthType width) 793 { 794 // delete the old list if we own it 795 // we always own the new list, which we create here (we duplicate rather 796 // than adopting the list passed in) 797 798 switch (context) { 799 case FORMAT : 800 switch (width) { 801 case WIDE : 802 if (fMonths) 803 delete[] fMonths; 804 fMonths = newUnicodeStringArray(count); 805 uprv_arrayCopy( monthsArray,fMonths,count); 806 fMonthsCount = count; 807 break; 808 case ABBREVIATED : 809 if (fShortMonths) 810 delete[] fShortMonths; 811 fShortMonths = newUnicodeStringArray(count); 812 uprv_arrayCopy( monthsArray,fShortMonths,count); 813 fShortMonthsCount = count; 814 break; 815 case NARROW : 816 if (fNarrowMonths) 817 delete[] fNarrowMonths; 818 fNarrowMonths = newUnicodeStringArray(count); 819 uprv_arrayCopy( monthsArray,fNarrowMonths,count); 820 fNarrowMonthsCount = count; 821 break; 822 case DT_WIDTH_COUNT : 823 break; 824 } 825 break; 826 case STANDALONE : 827 switch (width) { 828 case WIDE : 829 if (fStandaloneMonths) 830 delete[] fStandaloneMonths; 831 fStandaloneMonths = newUnicodeStringArray(count); 832 uprv_arrayCopy( monthsArray,fStandaloneMonths,count); 833 fStandaloneMonthsCount = count; 834 break; 835 case ABBREVIATED : 836 if (fStandaloneShortMonths) 837 delete[] fStandaloneShortMonths; 838 fStandaloneShortMonths = newUnicodeStringArray(count); 839 uprv_arrayCopy( monthsArray,fStandaloneShortMonths,count); 840 fStandaloneShortMonthsCount = count; 841 break; 842 case NARROW : 843 if (fStandaloneNarrowMonths) 844 delete[] fStandaloneNarrowMonths; 845 fStandaloneNarrowMonths = newUnicodeStringArray(count); 846 uprv_arrayCopy( monthsArray,fStandaloneNarrowMonths,count); 847 fStandaloneNarrowMonthsCount = count; 848 break; 849 case DT_WIDTH_COUNT : 850 break; 851 } 852 break; 853 case DT_CONTEXT_COUNT : 854 break; 855 } 856 } 857 858 void DateFormatSymbols::setWeekdays(const UnicodeString* weekdaysArray, int32_t count) 859 { 860 // delete the old list if we own it 861 if (fWeekdays) 862 delete[] fWeekdays; 863 864 // we always own the new list, which we create here (we duplicate rather 865 // than adopting the list passed in) 866 fWeekdays = newUnicodeStringArray(count); 867 uprv_arrayCopy(weekdaysArray,fWeekdays,count); 868 fWeekdaysCount = count; 869 } 870 871 void 872 DateFormatSymbols::setShortWeekdays(const UnicodeString* shortWeekdaysArray, int32_t count) 873 { 874 // delete the old list if we own it 875 if (fShortWeekdays) 876 delete[] fShortWeekdays; 877 878 // we always own the new list, which we create here (we duplicate rather 879 // than adopting the list passed in) 880 fShortWeekdays = newUnicodeStringArray(count); 881 uprv_arrayCopy(shortWeekdaysArray, fShortWeekdays, count); 882 fShortWeekdaysCount = count; 883 } 884 885 void 886 DateFormatSymbols::setWeekdays(const UnicodeString* weekdaysArray, int32_t count, DtContextType context, DtWidthType width) 887 { 888 // delete the old list if we own it 889 // we always own the new list, which we create here (we duplicate rather 890 // than adopting the list passed in) 891 892 switch (context) { 893 case FORMAT : 894 switch (width) { 895 case WIDE : 896 if (fWeekdays) 897 delete[] fWeekdays; 898 fWeekdays = newUnicodeStringArray(count); 899 uprv_arrayCopy(weekdaysArray, fWeekdays, count); 900 fWeekdaysCount = count; 901 break; 902 case ABBREVIATED : 903 if (fShortWeekdays) 904 delete[] fShortWeekdays; 905 fShortWeekdays = newUnicodeStringArray(count); 906 uprv_arrayCopy(weekdaysArray, fShortWeekdays, count); 907 fShortWeekdaysCount = count; 908 break; 909 case NARROW : 910 if (fNarrowWeekdays) 911 delete[] fNarrowWeekdays; 912 fNarrowWeekdays = newUnicodeStringArray(count); 913 uprv_arrayCopy(weekdaysArray, fNarrowWeekdays, count); 914 fNarrowWeekdaysCount = count; 915 break; 916 case DT_WIDTH_COUNT : 917 break; 918 } 919 break; 920 case STANDALONE : 921 switch (width) { 922 case WIDE : 923 if (fStandaloneWeekdays) 924 delete[] fStandaloneWeekdays; 925 fStandaloneWeekdays = newUnicodeStringArray(count); 926 uprv_arrayCopy(weekdaysArray, fStandaloneWeekdays, count); 927 fStandaloneWeekdaysCount = count; 928 break; 929 case ABBREVIATED : 930 if (fStandaloneShortWeekdays) 931 delete[] fStandaloneShortWeekdays; 932 fStandaloneShortWeekdays = newUnicodeStringArray(count); 933 uprv_arrayCopy(weekdaysArray, fStandaloneShortWeekdays, count); 934 fStandaloneShortWeekdaysCount = count; 935 break; 936 case NARROW : 937 if (fStandaloneNarrowWeekdays) 938 delete[] fStandaloneNarrowWeekdays; 939 fStandaloneNarrowWeekdays = newUnicodeStringArray(count); 940 uprv_arrayCopy(weekdaysArray, fStandaloneNarrowWeekdays, count); 941 fStandaloneNarrowWeekdaysCount = count; 942 break; 943 case DT_WIDTH_COUNT : 944 break; 945 } 946 break; 947 case DT_CONTEXT_COUNT : 948 break; 949 } 950 } 951 952 void 953 DateFormatSymbols::setQuarters(const UnicodeString* quartersArray, int32_t count, DtContextType context, DtWidthType width) 954 { 955 // delete the old list if we own it 956 // we always own the new list, which we create here (we duplicate rather 957 // than adopting the list passed in) 958 959 switch (context) { 960 case FORMAT : 961 switch (width) { 962 case WIDE : 963 if (fQuarters) 964 delete[] fQuarters; 965 fQuarters = newUnicodeStringArray(count); 966 uprv_arrayCopy( quartersArray,fQuarters,count); 967 fQuartersCount = count; 968 break; 969 case ABBREVIATED : 970 if (fShortQuarters) 971 delete[] fShortQuarters; 972 fShortQuarters = newUnicodeStringArray(count); 973 uprv_arrayCopy( quartersArray,fShortQuarters,count); 974 fShortQuartersCount = count; 975 break; 976 case NARROW : 977 /* 978 if (fNarrowQuarters) 979 delete[] fNarrowQuarters; 980 fNarrowQuarters = newUnicodeStringArray(count); 981 uprv_arrayCopy( quartersArray,fNarrowQuarters,count); 982 fNarrowQuartersCount = count; 983 */ 984 break; 985 case DT_WIDTH_COUNT : 986 break; 987 } 988 break; 989 case STANDALONE : 990 switch (width) { 991 case WIDE : 992 if (fStandaloneQuarters) 993 delete[] fStandaloneQuarters; 994 fStandaloneQuarters = newUnicodeStringArray(count); 995 uprv_arrayCopy( quartersArray,fStandaloneQuarters,count); 996 fStandaloneQuartersCount = count; 997 break; 998 case ABBREVIATED : 999 if (fStandaloneShortQuarters) 1000 delete[] fStandaloneShortQuarters; 1001 fStandaloneShortQuarters = newUnicodeStringArray(count); 1002 uprv_arrayCopy( quartersArray,fStandaloneShortQuarters,count); 1003 fStandaloneShortQuartersCount = count; 1004 break; 1005 case NARROW : 1006 /* 1007 if (fStandaloneNarrowQuarters) 1008 delete[] fStandaloneNarrowQuarters; 1009 fStandaloneNarrowQuarters = newUnicodeStringArray(count); 1010 uprv_arrayCopy( quartersArray,fStandaloneNarrowQuarters,count); 1011 fStandaloneNarrowQuartersCount = count; 1012 */ 1013 break; 1014 case DT_WIDTH_COUNT : 1015 break; 1016 } 1017 break; 1018 case DT_CONTEXT_COUNT : 1019 break; 1020 } 1021 } 1022 1023 void 1024 DateFormatSymbols::setAmPmStrings(const UnicodeString* amPmsArray, int32_t count) 1025 { 1026 // delete the old list if we own it 1027 if (fAmPms) delete[] fAmPms; 1028 1029 // we always own the new list, which we create here (we duplicate rather 1030 // than adopting the list passed in) 1031 fAmPms = newUnicodeStringArray(count); 1032 uprv_arrayCopy(amPmsArray,fAmPms,count); 1033 fAmPmsCount = count; 1034 } 1035 1036 //------------------------------------------------------ 1037 const ZoneStringFormat* 1038 DateFormatSymbols::getZoneStringFormat(void) const { 1039 umtx_lock(&LOCK); 1040 if (fZoneStringFormat == NULL) { 1041 ((DateFormatSymbols*)this)->initZoneStringFormat(); 1042 } 1043 umtx_unlock(&LOCK); 1044 return fZoneStringFormat; 1045 } 1046 1047 void 1048 DateFormatSymbols::initZoneStringFormat(void) { 1049 if (fZoneStringFormat == NULL) { 1050 UErrorCode status = U_ZERO_ERROR; 1051 if (fZoneStrings) { 1052 // Create an istance of ZoneStringFormat by the custom zone strings array 1053 fZSFLocal = new ZoneStringFormat(fZoneStrings, fZoneStringsRowCount, 1054 fZoneStringsColCount, status); 1055 if (U_FAILURE(status)) { 1056 delete fZSFLocal; 1057 } else { 1058 fZoneStringFormat = (const ZoneStringFormat*)fZSFLocal; 1059 } 1060 } else { 1061 fZSFCachePtr = ZoneStringFormat::getZoneStringFormat(fZSFLocale, status); 1062 if (U_FAILURE(status)) { 1063 delete fZSFCachePtr; 1064 } else { 1065 fZoneStringFormat = fZSFCachePtr->get(); 1066 } 1067 } 1068 } 1069 } 1070 1071 const UnicodeString** 1072 DateFormatSymbols::getZoneStrings(int32_t& rowCount, int32_t& columnCount) const 1073 { 1074 const UnicodeString **result = NULL; 1075 1076 umtx_lock(&LOCK); 1077 if (fZoneStrings == NULL) { 1078 if (fLocaleZoneStrings == NULL) { 1079 ((DateFormatSymbols*)this)->initZoneStringsArray(); 1080 } 1081 result = (const UnicodeString**)fLocaleZoneStrings; 1082 } else { 1083 result = (const UnicodeString**)fZoneStrings; 1084 } 1085 rowCount = fZoneStringsRowCount; 1086 columnCount = fZoneStringsColCount; 1087 umtx_unlock(&LOCK); 1088 1089 return result; 1090 } 1091 1092 void 1093 DateFormatSymbols::initZoneStringsArray(void) { 1094 if (fZoneStrings == NULL && fLocaleZoneStrings == NULL) { 1095 if (fZoneStringFormat == NULL) { 1096 initZoneStringFormat(); 1097 } 1098 if (fZoneStringFormat) { 1099 UErrorCode status = U_ZERO_ERROR; 1100 fLocaleZoneStrings = fZoneStringFormat->createZoneStringsArray(uprv_getUTCtime() /* use current time */, 1101 fZoneStringsRowCount, fZoneStringsColCount, status); 1102 } 1103 } 1104 } 1105 1106 void 1107 DateFormatSymbols::setZoneStrings(const UnicodeString* const *strings, int32_t rowCount, int32_t columnCount) 1108 { 1109 // since deleting a 2-d array is a pain in the butt, we offload that task to 1110 // a separate function 1111 disposeZoneStrings(); 1112 // we always own the new list, which we create here (we duplicate rather 1113 // than adopting the list passed in) 1114 fZoneStringsRowCount = rowCount; 1115 fZoneStringsColCount = columnCount; 1116 createZoneStrings((const UnicodeString**)strings); 1117 } 1118 1119 //------------------------------------------------------ 1120 1121 const UChar * U_EXPORT2 1122 DateFormatSymbols::getPatternUChars(void) 1123 { 1124 return gPatternChars; 1125 } 1126 1127 //------------------------------------------------------ 1128 1129 UnicodeString& 1130 DateFormatSymbols::getLocalPatternChars(UnicodeString& result) const 1131 { 1132 // fastCopyFrom() - see assignArray comments 1133 return result.fastCopyFrom(fLocalPatternChars); 1134 } 1135 1136 //------------------------------------------------------ 1137 1138 void 1139 DateFormatSymbols::setLocalPatternChars(const UnicodeString& newLocalPatternChars) 1140 { 1141 fLocalPatternChars = newLocalPatternChars; 1142 } 1143 1144 //------------------------------------------------------ 1145 1146 static void 1147 initField(UnicodeString **field, int32_t& length, const UResourceBundle *data, UErrorCode &status) { 1148 if (U_SUCCESS(status)) { 1149 int32_t strLen = 0; 1150 length = ures_getSize(data); 1151 *field = newUnicodeStringArray(length); 1152 if (*field) { 1153 for(int32_t i = 0; i<length; i++) { 1154 const UChar *resStr = ures_getStringByIndex(data, i, &strLen, &status); 1155 // setTo() - see assignArray comments 1156 (*(field)+i)->setTo(TRUE, resStr, strLen); 1157 } 1158 } 1159 else { 1160 length = 0; 1161 status = U_MEMORY_ALLOCATION_ERROR; 1162 } 1163 } 1164 } 1165 1166 static void 1167 initField(UnicodeString **field, int32_t& length, const UChar *data, LastResortSize numStr, LastResortSize strLen, UErrorCode &status) { 1168 if (U_SUCCESS(status)) { 1169 length = numStr; 1170 *field = newUnicodeStringArray((size_t)numStr); 1171 if (*field) { 1172 for(int32_t i = 0; i<length; i++) { 1173 // readonly aliases - all "data" strings are constant 1174 // -1 as length for variable-length strings (gLastResortDayNames[0] is empty) 1175 (*(field)+i)->setTo(TRUE, data+(i*((int32_t)strLen)), -1); 1176 } 1177 } 1178 else { 1179 length = 0; 1180 status = U_MEMORY_ALLOCATION_ERROR; 1181 } 1182 } 1183 } 1184 1185 void 1186 DateFormatSymbols::initializeData(const Locale& locale, const char *type, UErrorCode& status, UBool useLastResortData) 1187 { 1188 int32_t i; 1189 int32_t len = 0; 1190 const UChar *resStr; 1191 /* In case something goes wrong, initialize all of the data to NULL. */ 1192 fEras = NULL; 1193 fErasCount = 0; 1194 fEraNames = NULL; 1195 fEraNamesCount = 0; 1196 fNarrowEras = NULL; 1197 fNarrowErasCount = 0; 1198 fMonths = NULL; 1199 fMonthsCount=0; 1200 fShortMonths = NULL; 1201 fShortMonthsCount=0; 1202 fNarrowMonths = NULL; 1203 fNarrowMonthsCount=0; 1204 fStandaloneMonths = NULL; 1205 fStandaloneMonthsCount=0; 1206 fStandaloneShortMonths = NULL; 1207 fStandaloneShortMonthsCount=0; 1208 fStandaloneNarrowMonths = NULL; 1209 fStandaloneNarrowMonthsCount=0; 1210 fWeekdays = NULL; 1211 fWeekdaysCount=0; 1212 fShortWeekdays = NULL; 1213 fShortWeekdaysCount=0; 1214 fNarrowWeekdays = NULL; 1215 fNarrowWeekdaysCount=0; 1216 fStandaloneWeekdays = NULL; 1217 fStandaloneWeekdaysCount=0; 1218 fStandaloneShortWeekdays = NULL; 1219 fStandaloneShortWeekdaysCount=0; 1220 fStandaloneNarrowWeekdays = NULL; 1221 fStandaloneNarrowWeekdaysCount=0; 1222 fAmPms = NULL; 1223 fAmPmsCount=0; 1224 fQuarters = NULL; 1225 fQuartersCount = 0; 1226 fShortQuarters = NULL; 1227 fShortQuartersCount = 0; 1228 fStandaloneQuarters = NULL; 1229 fStandaloneQuartersCount = 0; 1230 fStandaloneShortQuarters = NULL; 1231 fStandaloneShortQuartersCount = 0; 1232 fGmtHourFormats = NULL; 1233 fGmtHourFormatsCount = 0; 1234 fZoneStringsRowCount = 0; 1235 fZoneStringsColCount = 0; 1236 fZoneStrings = NULL; 1237 fLocaleZoneStrings = NULL; 1238 1239 fZoneStringFormat = NULL; 1240 fZSFLocal = NULL; 1241 fZSFCachePtr = NULL; 1242 1243 // We need to preserve the requested locale for 1244 // lazy ZoneStringFormat instantiation. ZoneStringFormat 1245 // is region sensitive, thus, bundle locale bundle's locale 1246 // is not sufficient. 1247 fZSFLocale = locale; 1248 1249 if (U_FAILURE(status)) return; 1250 1251 /** 1252 * Retrieve the string arrays we need from the resource bundle file. 1253 * We cast away const here, but that's okay; we won't delete any of 1254 * these. 1255 */ 1256 CalendarData calData(locale, type, status); 1257 1258 /** 1259 * Use the localeBundle for getting zone GMT formatting patterns 1260 */ 1261 UResourceBundle *zoneBundle = ures_open(U_ICUDATA_ZONE, locale.getName(), &status); 1262 UResourceBundle *zoneStringsArray = ures_getByKeyWithFallback(zoneBundle, gZoneStringsTag, NULL, &status); 1263 1264 // load the first data item 1265 UResourceBundle *erasMain = calData.getByKey(gErasTag, status); 1266 UResourceBundle *eras = ures_getByKeyWithFallback(erasMain, gNamesAbbrTag, NULL, &status); 1267 UErrorCode oldStatus = status; 1268 UResourceBundle *eraNames = ures_getByKeyWithFallback(erasMain, gNamesWideTag, NULL, &status); 1269 if ( status == U_MISSING_RESOURCE_ERROR ) { // Workaround because eras/wide was omitted from CLDR 1.3 1270 status = oldStatus; 1271 eraNames = ures_getByKeyWithFallback(erasMain, gNamesAbbrTag, NULL, &status); 1272 } 1273 // current ICU4J falls back to abbreviated if narrow eras are missing, so we will too 1274 oldStatus = status; 1275 UResourceBundle *narrowEras = ures_getByKeyWithFallback(erasMain, gNamesNarrowTag, NULL, &status); 1276 if ( status == U_MISSING_RESOURCE_ERROR ) { 1277 status = oldStatus; 1278 narrowEras = ures_getByKeyWithFallback(erasMain, gNamesAbbrTag, NULL, &status); 1279 } 1280 1281 UResourceBundle *lsweekdaysData = NULL; // Data closed by calData 1282 UResourceBundle *weekdaysData = NULL; // Data closed by calData 1283 UResourceBundle *narrowWeekdaysData = NULL; // Data closed by calData 1284 UResourceBundle *standaloneWeekdaysData = NULL; // Data closed by calData 1285 UResourceBundle *standaloneShortWeekdaysData = NULL; // Data closed by calData 1286 UResourceBundle *standaloneNarrowWeekdaysData = NULL; // Data closed by calData 1287 1288 U_LOCALE_BASED(locBased, *this); 1289 if (U_FAILURE(status)) 1290 { 1291 if (useLastResortData) 1292 { 1293 // Handle the case in which there is no resource data present. 1294 // We don't have to generate usable patterns in this situation; 1295 // we just need to produce something that will be semi-intelligible 1296 // in most locales. 1297 1298 status = U_USING_FALLBACK_WARNING; 1299 1300 initField(&fEras, fErasCount, (const UChar *)gLastResortEras, kEraNum, kEraLen, status); 1301 initField(&fEraNames, fEraNamesCount, (const UChar *)gLastResortEras, kEraNum, kEraLen, status); 1302 initField(&fNarrowEras, fNarrowErasCount, (const UChar *)gLastResortEras, kEraNum, kEraLen, status); 1303 initField(&fMonths, fMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); 1304 initField(&fShortMonths, fShortMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); 1305 initField(&fNarrowMonths, fNarrowMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); 1306 initField(&fStandaloneMonths, fStandaloneMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); 1307 initField(&fStandaloneShortMonths, fStandaloneShortMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); 1308 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, (const UChar *)gLastResortMonthNames, kMonthNum, kMonthLen, status); 1309 initField(&fWeekdays, fWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1310 initField(&fShortWeekdays, fShortWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1311 initField(&fNarrowWeekdays, fNarrowWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1312 initField(&fStandaloneWeekdays, fStandaloneWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1313 initField(&fStandaloneShortWeekdays, fStandaloneShortWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1314 initField(&fStandaloneNarrowWeekdays, fStandaloneNarrowWeekdaysCount, (const UChar *)gLastResortDayNames, kDayNum, kDayLen, status); 1315 initField(&fAmPms, fAmPmsCount, (const UChar *)gLastResortAmPmMarkers, kAmPmNum, kAmPmLen, status); 1316 initField(&fQuarters, fQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status); 1317 initField(&fShortQuarters, fShortQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status); 1318 initField(&fStandaloneQuarters, fStandaloneQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status); 1319 initField(&fStandaloneShortQuarters, fStandaloneShortQuartersCount, (const UChar *)gLastResortQuarters, kQuarterNum, kQuarterLen, status); 1320 initField(&fGmtHourFormats, fGmtHourFormatsCount, (const UChar *)gLastResortGmtHourFormats, kGmtHourNum, kGmtHourLen, status); 1321 fGmtFormat.setTo(TRUE, gLastResortGmtFormat, -1); 1322 fLocalPatternChars.setTo(TRUE, gPatternChars, PATTERN_CHARS_LEN); 1323 } 1324 goto cleanup; 1325 } 1326 1327 // if we make it to here, the resource data is cool, and we can get everything out 1328 // of it that we need except for the time-zone and localized-pattern data, which 1329 // are stored in a separate file 1330 locBased.setLocaleIDs(ures_getLocaleByType(eras, ULOC_VALID_LOCALE, &status), 1331 ures_getLocaleByType(eras, ULOC_ACTUAL_LOCALE, &status)); 1332 1333 initField(&fEras, fErasCount, eras, status); 1334 initField(&fEraNames, fEraNamesCount, eraNames, status); 1335 initField(&fNarrowEras, fNarrowErasCount, narrowEras, status); 1336 1337 initField(&fMonths, fMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesWideTag, status), status); 1338 initField(&fShortMonths, fShortMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesAbbrTag, status), status); 1339 1340 initField(&fNarrowMonths, fNarrowMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesNarrowTag, status), status); 1341 if(status == U_MISSING_RESOURCE_ERROR) { 1342 status = U_ZERO_ERROR; 1343 initField(&fNarrowMonths, fNarrowMonthsCount, calData.getByKey3(gMonthNamesTag, gNamesStandaloneTag, gNamesNarrowTag, status), status); 1344 } 1345 if ( status == U_MISSING_RESOURCE_ERROR ) { /* If format/narrow not available, use format/abbreviated */ 1346 status = U_ZERO_ERROR; 1347 initField(&fNarrowMonths, fNarrowMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesAbbrTag, status), status); 1348 } 1349 1350 initField(&fStandaloneMonths, fStandaloneMonthsCount, calData.getByKey3(gMonthNamesTag, gNamesStandaloneTag, gNamesWideTag, status), status); 1351 if ( status == U_MISSING_RESOURCE_ERROR ) { /* If standalone/wide not available, use format/wide */ 1352 status = U_ZERO_ERROR; 1353 initField(&fStandaloneMonths, fStandaloneMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesWideTag, status), status); 1354 } 1355 initField(&fStandaloneShortMonths, fStandaloneShortMonthsCount, calData.getByKey3(gMonthNamesTag, gNamesStandaloneTag, gNamesAbbrTag, status), status); 1356 if ( status == U_MISSING_RESOURCE_ERROR ) { /* If standalone/abbreviated not available, use format/abbreviated */ 1357 status = U_ZERO_ERROR; 1358 initField(&fStandaloneShortMonths, fStandaloneShortMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesAbbrTag, status), status); 1359 } 1360 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, calData.getByKey3(gMonthNamesTag, gNamesStandaloneTag, gNamesNarrowTag, status), status); 1361 if ( status == U_MISSING_RESOURCE_ERROR ) { /* if standalone/narrow not availabe, try format/narrow */ 1362 status = U_ZERO_ERROR; 1363 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesNarrowTag, status), status); 1364 if ( status == U_MISSING_RESOURCE_ERROR ) { /* if still not there, use format/abbreviated */ 1365 status = U_ZERO_ERROR; 1366 initField(&fStandaloneNarrowMonths, fStandaloneNarrowMonthsCount, calData.getByKey2(gMonthNamesTag, gNamesAbbrTag, status), status); 1367 } 1368 } 1369 initField(&fAmPms, fAmPmsCount, calData.getByKey(gAmPmMarkersTag, status), status); 1370 1371 initField(&fQuarters, fQuartersCount, calData.getByKey2(gQuartersTag, gNamesWideTag, status), status); 1372 initField(&fShortQuarters, fShortQuartersCount, calData.getByKey2(gQuartersTag, gNamesAbbrTag, status), status); 1373 1374 initField(&fStandaloneQuarters, fStandaloneQuartersCount, calData.getByKey3(gQuartersTag, gNamesStandaloneTag, gNamesWideTag, status), status); 1375 if(status == U_MISSING_RESOURCE_ERROR) { 1376 status = U_ZERO_ERROR; 1377 initField(&fStandaloneQuarters, fStandaloneQuartersCount, calData.getByKey2(gQuartersTag, gNamesWideTag, status), status); 1378 } 1379 1380 initField(&fStandaloneShortQuarters, fStandaloneShortQuartersCount, calData.getByKey3(gQuartersTag, gNamesStandaloneTag, gNamesAbbrTag, status), status); 1381 if(status == U_MISSING_RESOURCE_ERROR) { 1382 status = U_ZERO_ERROR; 1383 initField(&fStandaloneShortQuarters, fStandaloneShortQuartersCount, calData.getByKey2(gQuartersTag, gNamesAbbrTag, status), status); 1384 } 1385 1386 // GMT format patterns 1387 resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gGmtFormatTag, &len, &status); 1388 if (len > 0) { 1389 fGmtFormat.setTo(TRUE, resStr, len); 1390 } 1391 1392 resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gHourFormatTag, &len, &status); 1393 if (len > 0) { 1394 UChar *sep = u_strchr(resStr, (UChar)0x003B /* ';' */); 1395 if (sep != NULL) { 1396 fGmtHourFormats = newUnicodeStringArray(GMT_HOUR_COUNT); 1397 if (fGmtHourFormats == NULL) { 1398 status = U_MEMORY_ALLOCATION_ERROR; 1399 } else { 1400 fGmtHourFormatsCount = GMT_HOUR_COUNT; 1401 fGmtHourFormats[GMT_NEGATIVE_HM].setTo(TRUE, sep + 1, -1); 1402 fGmtHourFormats[GMT_POSITIVE_HM].setTo(FALSE, resStr, (int32_t)(sep - resStr)); 1403 1404 // CLDR 1.5 does not have GMT offset pattern including second field. 1405 // For now, append "ss" to the end. 1406 if (fGmtHourFormats[GMT_NEGATIVE_HM].indexOf((UChar)0x003A /* ':' */) != -1) { 1407 fGmtHourFormats[GMT_NEGATIVE_HMS] = fGmtHourFormats[GMT_NEGATIVE_HM] + UNICODE_STRING_SIMPLE(":ss"); 1408 } else if (fGmtHourFormats[GMT_NEGATIVE_HM].indexOf((UChar)0x002E /* '.' */) != -1) { 1409 fGmtHourFormats[GMT_NEGATIVE_HMS] = fGmtHourFormats[GMT_NEGATIVE_HM] + UNICODE_STRING_SIMPLE(".ss"); 1410 } else { 1411 fGmtHourFormats[GMT_NEGATIVE_HMS] = fGmtHourFormats[GMT_NEGATIVE_HM] + UNICODE_STRING_SIMPLE("ss"); 1412 } 1413 if (fGmtHourFormats[GMT_POSITIVE_HM].indexOf((UChar)0x003A /* ':' */) != -1) { 1414 fGmtHourFormats[GMT_POSITIVE_HMS] = fGmtHourFormats[GMT_POSITIVE_HM] + UNICODE_STRING_SIMPLE(":ss"); 1415 } else if (fGmtHourFormats[GMT_POSITIVE_HM].indexOf((UChar)0x002E /* '.' */) != -1) { 1416 fGmtHourFormats[GMT_POSITIVE_HMS] = fGmtHourFormats[GMT_POSITIVE_HM] + UNICODE_STRING_SIMPLE(".ss"); 1417 } else { 1418 fGmtHourFormats[GMT_POSITIVE_HMS] = fGmtHourFormats[GMT_POSITIVE_HM] + UNICODE_STRING_SIMPLE("ss"); 1419 } 1420 } 1421 } 1422 } 1423 1424 // ICU 3.8 or later version no longer uses localized date-time pattern characters by default (ticket#5597) 1425 /* 1426 // fastCopyFrom()/setTo() - see assignArray comments 1427 resStr = ures_getStringByKey(fResourceBundle, gLocalPatternCharsTag, &len, &status); 1428 fLocalPatternChars.setTo(TRUE, resStr, len); 1429 // If the locale data does not include new pattern chars, use the defaults 1430 // TODO: Consider making this an error, since this may add conflicting characters. 1431 if (len < PATTERN_CHARS_LEN) { 1432 fLocalPatternChars.append(UnicodeString(TRUE, &gPatternChars[len], PATTERN_CHARS_LEN-len)); 1433 } 1434 */ 1435 fLocalPatternChars.setTo(TRUE, gPatternChars, PATTERN_CHARS_LEN); 1436 1437 // {sfb} fixed to handle 1-based weekdays 1438 weekdaysData = calData.getByKey2(gDayNamesTag, gNamesWideTag, status); 1439 fWeekdaysCount = ures_getSize(weekdaysData); 1440 fWeekdays = new UnicodeString[fWeekdaysCount+1]; 1441 /* pin the blame on system. If we cannot get a chunk of memory .. the system is dying!*/ 1442 if (fWeekdays == NULL) { 1443 status = U_MEMORY_ALLOCATION_ERROR; 1444 goto cleanup; 1445 } 1446 // leave fWeekdays[0] empty 1447 for(i = 0; i<fWeekdaysCount; i++) { 1448 resStr = ures_getStringByIndex(weekdaysData, i, &len, &status); 1449 // setTo() - see assignArray comments 1450 fWeekdays[i+1].setTo(TRUE, resStr, len); 1451 } 1452 fWeekdaysCount++; 1453 1454 lsweekdaysData = calData.getByKey2(gDayNamesTag, gNamesAbbrTag, status); 1455 fShortWeekdaysCount = ures_getSize(lsweekdaysData); 1456 fShortWeekdays = new UnicodeString[fShortWeekdaysCount+1]; 1457 /* test for NULL */ 1458 if (fShortWeekdays == 0) { 1459 status = U_MEMORY_ALLOCATION_ERROR; 1460 goto cleanup; 1461 } 1462 // leave fShortWeekdays[0] empty 1463 for(i = 0; i<fShortWeekdaysCount; i++) { 1464 resStr = ures_getStringByIndex(lsweekdaysData, i, &len, &status); 1465 // setTo() - see assignArray comments 1466 fShortWeekdays[i+1].setTo(TRUE, resStr, len); 1467 } 1468 fShortWeekdaysCount++; 1469 1470 narrowWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesNarrowTag, status); 1471 if(status == U_MISSING_RESOURCE_ERROR) { 1472 status = U_ZERO_ERROR; 1473 narrowWeekdaysData = calData.getByKey3(gDayNamesTag, gNamesStandaloneTag, gNamesNarrowTag, status); 1474 } 1475 if ( status == U_MISSING_RESOURCE_ERROR ) { 1476 status = U_ZERO_ERROR; 1477 narrowWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesAbbrTag, status); 1478 } 1479 fNarrowWeekdaysCount = ures_getSize(narrowWeekdaysData); 1480 fNarrowWeekdays = new UnicodeString[fNarrowWeekdaysCount+1]; 1481 /* test for NULL */ 1482 if (fNarrowWeekdays == 0) { 1483 status = U_MEMORY_ALLOCATION_ERROR; 1484 goto cleanup; 1485 } 1486 // leave fNarrowWeekdays[0] empty 1487 for(i = 0; i<fNarrowWeekdaysCount; i++) { 1488 resStr = ures_getStringByIndex(narrowWeekdaysData, i, &len, &status); 1489 // setTo() - see assignArray comments 1490 fNarrowWeekdays[i+1].setTo(TRUE, resStr, len); 1491 } 1492 fNarrowWeekdaysCount++; 1493 1494 standaloneWeekdaysData = calData.getByKey3(gDayNamesTag, gNamesStandaloneTag, gNamesWideTag, status); 1495 if ( status == U_MISSING_RESOURCE_ERROR ) { 1496 status = U_ZERO_ERROR; 1497 standaloneWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesWideTag, status); 1498 } 1499 fStandaloneWeekdaysCount = ures_getSize(standaloneWeekdaysData); 1500 fStandaloneWeekdays = new UnicodeString[fStandaloneWeekdaysCount+1]; 1501 /* test for NULL */ 1502 if (fStandaloneWeekdays == 0) { 1503 status = U_MEMORY_ALLOCATION_ERROR; 1504 goto cleanup; 1505 } 1506 // leave fStandaloneWeekdays[0] empty 1507 for(i = 0; i<fStandaloneWeekdaysCount; i++) { 1508 resStr = ures_getStringByIndex(standaloneWeekdaysData, i, &len, &status); 1509 // setTo() - see assignArray comments 1510 fStandaloneWeekdays[i+1].setTo(TRUE, resStr, len); 1511 } 1512 fStandaloneWeekdaysCount++; 1513 1514 standaloneShortWeekdaysData = calData.getByKey3(gDayNamesTag, gNamesStandaloneTag, gNamesAbbrTag, status); 1515 if ( status == U_MISSING_RESOURCE_ERROR ) { 1516 status = U_ZERO_ERROR; 1517 standaloneShortWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesAbbrTag, status); 1518 } 1519 fStandaloneShortWeekdaysCount = ures_getSize(standaloneShortWeekdaysData); 1520 fStandaloneShortWeekdays = new UnicodeString[fStandaloneShortWeekdaysCount+1]; 1521 /* test for NULL */ 1522 if (fStandaloneShortWeekdays == 0) { 1523 status = U_MEMORY_ALLOCATION_ERROR; 1524 goto cleanup; 1525 } 1526 // leave fStandaloneShortWeekdays[0] empty 1527 for(i = 0; i<fStandaloneShortWeekdaysCount; i++) { 1528 resStr = ures_getStringByIndex(standaloneShortWeekdaysData, i, &len, &status); 1529 // setTo() - see assignArray comments 1530 fStandaloneShortWeekdays[i+1].setTo(TRUE, resStr, len); 1531 } 1532 fStandaloneShortWeekdaysCount++; 1533 1534 standaloneNarrowWeekdaysData = calData.getByKey3(gDayNamesTag, gNamesStandaloneTag, gNamesNarrowTag, status); 1535 if ( status == U_MISSING_RESOURCE_ERROR ) { 1536 status = U_ZERO_ERROR; 1537 standaloneNarrowWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesNarrowTag, status); 1538 if ( status == U_MISSING_RESOURCE_ERROR ) { 1539 status = U_ZERO_ERROR; 1540 standaloneNarrowWeekdaysData = calData.getByKey2(gDayNamesTag, gNamesAbbrTag, status); 1541 } 1542 } 1543 fStandaloneNarrowWeekdaysCount = ures_getSize(standaloneNarrowWeekdaysData); 1544 fStandaloneNarrowWeekdays = new UnicodeString[fStandaloneNarrowWeekdaysCount+1]; 1545 /* test for NULL */ 1546 if (fStandaloneNarrowWeekdays == 0) { 1547 status = U_MEMORY_ALLOCATION_ERROR; 1548 goto cleanup; 1549 } 1550 // leave fStandaloneNarrowWeekdays[0] empty 1551 for(i = 0; i<fStandaloneNarrowWeekdaysCount; i++) { 1552 resStr = ures_getStringByIndex(standaloneNarrowWeekdaysData, i, &len, &status); 1553 // setTo() - see assignArray comments 1554 fStandaloneNarrowWeekdays[i+1].setTo(TRUE, resStr, len); 1555 } 1556 fStandaloneNarrowWeekdaysCount++; 1557 1558 cleanup: 1559 ures_close(eras); 1560 ures_close(eraNames); 1561 ures_close(narrowEras); 1562 ures_close(zoneStringsArray); 1563 ures_close(zoneBundle); 1564 } 1565 1566 Locale 1567 DateFormatSymbols::getLocale(ULocDataLocaleType type, UErrorCode& status) const { 1568 U_LOCALE_BASED(locBased, *this); 1569 return locBased.getLocale(type, status); 1570 } 1571 1572 U_NAMESPACE_END 1573 1574 #endif /* #if !UCONFIG_NO_FORMATTING */ 1575 1576 //eof 1577
