1 /* 2 ********************************************************************** 3 * Copyright (c) 2002-2006, International Business Machines 4 * Corporation and others. All Rights Reserved. 5 ********************************************************************** 6 * Author: Alan Liu 7 * Created: October 30 2002 8 * Since: ICU 2.4 9 ********************************************************************** 10 */ 11 #include "propname.h" 12 #include "unicode/uchar.h" 13 #include "unicode/udata.h" 14 #include "umutex.h" 15 #include "cmemory.h" 16 #include "cstring.h" 17 #include "ucln_cmn.h" 18 #include "uarrsort.h" 19 20 U_CDECL_BEGIN 21 22 /** 23 * Get the next non-ignorable ASCII character from a property name 24 * and lowercases it. 25 * @return ((advance count for the name)<<8)|character 26 */ 27 static inline int32_t 28 getASCIIPropertyNameChar(const char *name) { 29 int32_t i; 30 char c; 31 32 /* Ignore delimiters '-', '_', and ASCII White_Space */ 33 for(i=0; 34 (c=name[i++])==0x2d || c==0x5f || 35 c==0x20 || (0x09<=c && c<=0x0d); 36 ) {} 37 38 if(c!=0) { 39 return (i<<8)|(uint8_t)uprv_asciitolower((char)c); 40 } else { 41 return i<<8; 42 } 43 } 44 45 /** 46 * Get the next non-ignorable EBCDIC character from a property name 47 * and lowercases it. 48 * @return ((advance count for the name)<<8)|character 49 */ 50 static inline int32_t 51 getEBCDICPropertyNameChar(const char *name) { 52 int32_t i; 53 char c; 54 55 /* Ignore delimiters '-', '_', and EBCDIC White_Space */ 56 for(i=0; 57 (c=name[i++])==0x60 || c==0x6d || 58 c==0x40 || c==0x05 || c==0x15 || c==0x25 || c==0x0b || c==0x0c || c==0x0d; 59 ) {} 60 61 if(c!=0) { 62 return (i<<8)|(uint8_t)uprv_ebcdictolower((char)c); 63 } else { 64 return i<<8; 65 } 66 } 67 68 /** 69 * Unicode property names and property value names are compared "loosely". 70 * 71 * UCD.html 4.0.1 says: 72 * For all property names, property value names, and for property values for 73 * Enumerated, Binary, or Catalog properties, use the following 74 * loose matching rule: 75 * 76 * LM3. Ignore case, whitespace, underscore ('_'), and hyphens. 77 * 78 * This function does just that, for (char *) name strings. 79 * It is almost identical to ucnv_compareNames() but also ignores 80 * C0 White_Space characters (U+0009..U+000d, and U+0085 on EBCDIC). 81 * 82 * @internal 83 */ 84 85 U_CAPI int32_t U_EXPORT2 86 uprv_compareASCIIPropertyNames(const char *name1, const char *name2) { 87 int32_t rc, r1, r2; 88 89 for(;;) { 90 r1=getASCIIPropertyNameChar(name1); 91 r2=getASCIIPropertyNameChar(name2); 92 93 /* If we reach the ends of both strings then they match */ 94 if(((r1|r2)&0xff)==0) { 95 return 0; 96 } 97 98 /* Compare the lowercased characters */ 99 if(r1!=r2) { 100 rc=(r1&0xff)-(r2&0xff); 101 if(rc!=0) { 102 return rc; 103 } 104 } 105 106 name1+=r1>>8; 107 name2+=r2>>8; 108 } 109 } 110 111 U_CAPI int32_t U_EXPORT2 112 uprv_compareEBCDICPropertyNames(const char *name1, const char *name2) { 113 int32_t rc, r1, r2; 114 115 for(;;) { 116 r1=getEBCDICPropertyNameChar(name1); 117 r2=getEBCDICPropertyNameChar(name2); 118 119 /* If we reach the ends of both strings then they match */ 120 if(((r1|r2)&0xff)==0) { 121 return 0; 122 } 123 124 /* Compare the lowercased characters */ 125 if(r1!=r2) { 126 rc=(r1&0xff)-(r2&0xff); 127 if(rc!=0) { 128 return rc; 129 } 130 } 131 132 name1+=r1>>8; 133 name2+=r2>>8; 134 } 135 } 136 137 U_CDECL_END 138 139 U_NAMESPACE_BEGIN 140 141 //---------------------------------------------------------------------- 142 // PropertyAliases implementation 143 144 const char* 145 PropertyAliases::chooseNameInGroup(Offset offset, 146 UPropertyNameChoice choice) const { 147 int32_t c = choice; 148 if (!offset || c < 0) { 149 return NULL; 150 } 151 const Offset* p = (const Offset*) getPointer(offset); 152 while (c-- > 0) { 153 if (*p++ < 0) return NULL; 154 } 155 Offset a = *p; 156 if (a < 0) a = -a; 157 return (const char*) getPointerNull(a); 158 } 159 160 const ValueMap* 161 PropertyAliases::getValueMap(EnumValue prop) const { 162 NonContiguousEnumToOffset* e2o = (NonContiguousEnumToOffset*) getPointer(enumToValue_offset); 163 Offset a = e2o->getOffset(prop); 164 return (const ValueMap*) (a ? getPointerNull(a) : NULL); 165 } 166 167 inline const char* 168 PropertyAliases::getPropertyName(EnumValue prop, 169 UPropertyNameChoice choice) const { 170 NonContiguousEnumToOffset* e2n = (NonContiguousEnumToOffset*) getPointer(enumToName_offset); 171 return chooseNameInGroup(e2n->getOffset(prop), choice); 172 } 173 174 inline EnumValue 175 PropertyAliases::getPropertyEnum(const char* alias) const { 176 NameToEnum* n2e = (NameToEnum*) getPointer(nameToEnum_offset); 177 return n2e->getEnum(alias, *this); 178 } 179 180 inline const char* 181 PropertyAliases::getPropertyValueName(EnumValue prop, 182 EnumValue value, 183 UPropertyNameChoice choice) const { 184 const ValueMap* vm = getValueMap(prop); 185 if (!vm) return NULL; 186 Offset a; 187 if (vm->enumToName_offset) { 188 a = ((EnumToOffset*) getPointer(vm->enumToName_offset))-> 189 getOffset(value); 190 } else { 191 a = ((NonContiguousEnumToOffset*) getPointer(vm->ncEnumToName_offset))-> 192 getOffset(value); 193 } 194 return chooseNameInGroup(a, choice); 195 } 196 197 inline EnumValue 198 PropertyAliases::getPropertyValueEnum(EnumValue prop, 199 const char* alias) const { 200 const ValueMap* vm = getValueMap(prop); 201 if (!vm) return UCHAR_INVALID_CODE; 202 NameToEnum* n2e = (NameToEnum*) getPointer(vm->nameToEnum_offset); 203 return n2e->getEnum(alias, *this); 204 } 205 206 U_NAMESPACE_END 207 U_NAMESPACE_USE 208 209 //---------------------------------------------------------------------- 210 // UDataMemory structures 211 212 static const PropertyAliases* PNAME = NULL; 213 static UDataMemory* UDATA = NULL; 214 215 //---------------------------------------------------------------------- 216 // UDataMemory loading/unloading 217 218 /** 219 * udata callback to verify the zone data. 220 */ 221 U_CDECL_BEGIN 222 static UBool U_CALLCONV 223 isPNameAcceptable(void* /*context*/, 224 const char* /*type*/, const char* /*name*/, 225 const UDataInfo* info) { 226 return 227 info->size >= sizeof(UDataInfo) && 228 info->isBigEndian == U_IS_BIG_ENDIAN && 229 info->charsetFamily == U_CHARSET_FAMILY && 230 info->dataFormat[0] == PNAME_SIG_0 && 231 info->dataFormat[1] == PNAME_SIG_1 && 232 info->dataFormat[2] == PNAME_SIG_2 && 233 info->dataFormat[3] == PNAME_SIG_3 && 234 info->formatVersion[0] == PNAME_FORMAT_VERSION; 235 } 236 237 static UBool U_CALLCONV pname_cleanup(void) { 238 if (UDATA) { 239 udata_close(UDATA); 240 UDATA = NULL; 241 } 242 PNAME = NULL; 243 return TRUE; 244 } 245 U_CDECL_END 246 247 /** 248 * Load the property names data. Caller should check that data is 249 * not loaded BEFORE calling this function. Returns TRUE if the load 250 * succeeds. 251 */ 252 static UBool _load() { 253 UErrorCode ec = U_ZERO_ERROR; 254 UDataMemory* data = 255 udata_openChoice(0, PNAME_DATA_TYPE, PNAME_DATA_NAME, 256 isPNameAcceptable, 0, &ec); 257 if (U_SUCCESS(ec)) { 258 umtx_lock(NULL); 259 if (UDATA == NULL) { 260 UDATA = data; 261 PNAME = (const PropertyAliases*) udata_getMemory(UDATA); 262 ucln_common_registerCleanup(UCLN_COMMON_PNAME, pname_cleanup); 263 data = NULL; 264 } 265 umtx_unlock(NULL); 266 } 267 if (data) { 268 udata_close(data); 269 } 270 return PNAME!=NULL; 271 } 272 273 /** 274 * Inline function that expands to code that does a lazy load of the 275 * property names data. If the data is already loaded, avoids an 276 * unnecessary function call. If the data is not loaded, call _load() 277 * to load it, and return TRUE if the load succeeds. 278 */ 279 static inline UBool load() { 280 UBool f; 281 UMTX_CHECK(NULL, (PNAME!=NULL), f); 282 return f || _load(); 283 } 284 285 //---------------------------------------------------------------------- 286 // Public API implementation 287 288 // The C API is just a thin wrapper. Each function obtains a pointer 289 // to the singleton PropertyAliases, and calls the appropriate method 290 // on it. If it cannot obtain a pointer, because valid data is not 291 // available, then it returns NULL or UCHAR_INVALID_CODE. 292 293 U_CAPI const char* U_EXPORT2 294 u_getPropertyName(UProperty property, 295 UPropertyNameChoice nameChoice) { 296 return load() ? PNAME->getPropertyName(property, nameChoice) 297 : NULL; 298 } 299 300 U_CAPI UProperty U_EXPORT2 301 u_getPropertyEnum(const char* alias) { 302 UProperty p = load() ? (UProperty) PNAME->getPropertyEnum(alias) 303 : UCHAR_INVALID_CODE; 304 return p; 305 } 306 307 U_CAPI const char* U_EXPORT2 308 u_getPropertyValueName(UProperty property, 309 int32_t value, 310 UPropertyNameChoice nameChoice) { 311 return load() ? PNAME->getPropertyValueName(property, value, nameChoice) 312 : NULL; 313 } 314 315 U_CAPI int32_t U_EXPORT2 316 u_getPropertyValueEnum(UProperty property, 317 const char* alias) { 318 return load() ? PNAME->getPropertyValueEnum(property, alias) 319 : (int32_t)UCHAR_INVALID_CODE; 320 } 321 322 /* data swapping ------------------------------------------------------------ */ 323 324 /* 325 * Sub-structure-swappers use the temp array (which is as large as the 326 * actual data) for intermediate storage, 327 * as well as to indicate if a particular structure has been swapped already. 328 * The temp array is initially reset to all 0. 329 * pos is the byte offset of the sub-structure in the inBytes/outBytes/temp arrays. 330 */ 331 332 int32_t 333 EnumToOffset::swap(const UDataSwapper *ds, 334 const uint8_t *inBytes, int32_t length, uint8_t *outBytes, 335 uint8_t *temp, int32_t pos, 336 UErrorCode *pErrorCode) { 337 const EnumToOffset *inMap; 338 EnumToOffset *outMap, *tempMap; 339 int32_t size; 340 341 tempMap=(EnumToOffset *)(temp+pos); 342 if(tempMap->enumStart!=0 || tempMap->enumLimit!=0) { 343 /* this map was swapped already */ 344 size=tempMap->getSize(); 345 return size; 346 } 347 348 inMap=(const EnumToOffset *)(inBytes+pos); 349 outMap=(EnumToOffset *)(outBytes+pos); 350 351 tempMap->enumStart=udata_readInt32(ds, inMap->enumStart); 352 tempMap->enumLimit=udata_readInt32(ds, inMap->enumLimit); 353 size=tempMap->getSize(); 354 355 if(length>=0) { 356 if(length<(pos+size)) { 357 if(length<(int32_t)sizeof(PropertyAliases)) { 358 udata_printError(ds, "upname_swap(EnumToOffset): too few bytes (%d after header)\n" 359 " for pnames.icu EnumToOffset{%d..%d} at %d\n", 360 length, tempMap->enumStart, tempMap->enumLimit, pos); 361 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; 362 return 0; 363 } 364 } 365 366 /* swap enumStart and enumLimit */ 367 ds->swapArray32(ds, inMap, 2*sizeof(EnumValue), outMap, pErrorCode); 368 369 /* swap _offsetArray[] */ 370 ds->swapArray16(ds, inMap->getOffsetArray(), (tempMap->enumLimit-tempMap->enumStart)*sizeof(Offset), 371 outMap->getOffsetArray(), pErrorCode); 372 } 373 374 return size; 375 } 376 377 int32_t 378 NonContiguousEnumToOffset::swap(const UDataSwapper *ds, 379 const uint8_t *inBytes, int32_t length, uint8_t *outBytes, 380 uint8_t *temp, int32_t pos, 381 UErrorCode *pErrorCode) { 382 const NonContiguousEnumToOffset *inMap; 383 NonContiguousEnumToOffset *outMap, *tempMap; 384 int32_t size; 385 386 tempMap=(NonContiguousEnumToOffset *)(temp+pos); 387 if(tempMap->count!=0) { 388 /* this map was swapped already */ 389 size=tempMap->getSize(); 390 return size; 391 } 392 393 inMap=(const NonContiguousEnumToOffset *)(inBytes+pos); 394 outMap=(NonContiguousEnumToOffset *)(outBytes+pos); 395 396 tempMap->count=udata_readInt32(ds, inMap->count); 397 size=tempMap->getSize(); 398 399 if(length>=0) { 400 if(length<(pos+size)) { 401 if(length<(int32_t)sizeof(PropertyAliases)) { 402 udata_printError(ds, "upname_swap(NonContiguousEnumToOffset): too few bytes (%d after header)\n" 403 " for pnames.icu NonContiguousEnumToOffset[%d] at %d\n", 404 length, tempMap->count, pos); 405 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; 406 return 0; 407 } 408 } 409 410 /* swap count and _enumArray[] */ 411 length=(1+tempMap->count)*sizeof(EnumValue); 412 ds->swapArray32(ds, inMap, length, 413 outMap, pErrorCode); 414 415 /* swap _offsetArray[] */ 416 pos+=length; 417 ds->swapArray16(ds, inBytes+pos, tempMap->count*sizeof(Offset), 418 outBytes+pos, pErrorCode); 419 } 420 421 return size; 422 } 423 424 struct NameAndIndex { 425 Offset name, index; 426 }; 427 428 U_CDECL_BEGIN 429 typedef int32_t U_CALLCONV PropNameCompareFn(const char *name1, const char *name2); 430 431 struct CompareContext { 432 const char *chars; 433 PropNameCompareFn *propCompare; 434 }; 435 436 static int32_t U_CALLCONV 437 upname_compareRows(const void *context, const void *left, const void *right) { 438 CompareContext *cmp=(CompareContext *)context; 439 return cmp->propCompare(cmp->chars+((const NameAndIndex *)left)->name, 440 cmp->chars+((const NameAndIndex *)right)->name); 441 } 442 U_CDECL_END 443 444 int32_t 445 NameToEnum::swap(const UDataSwapper *ds, 446 const uint8_t *inBytes, int32_t length, uint8_t *outBytes, 447 uint8_t *temp, int32_t pos, 448 UErrorCode *pErrorCode) { 449 const NameToEnum *inMap; 450 NameToEnum *outMap, *tempMap; 451 452 const EnumValue *inEnumArray; 453 EnumValue *outEnumArray; 454 455 const Offset *inNameArray; 456 Offset *outNameArray; 457 458 NameAndIndex *sortArray; 459 CompareContext cmp; 460 461 int32_t i, size, oldIndex; 462 463 tempMap=(NameToEnum *)(temp+pos); 464 if(tempMap->count!=0) { 465 /* this map was swapped already */ 466 size=tempMap->getSize(); 467 return size; 468 } 469 470 inMap=(const NameToEnum *)(inBytes+pos); 471 outMap=(NameToEnum *)(outBytes+pos); 472 473 tempMap->count=udata_readInt32(ds, inMap->count); 474 size=tempMap->getSize(); 475 476 if(length>=0) { 477 if(length<(pos+size)) { 478 if(length<(int32_t)sizeof(PropertyAliases)) { 479 udata_printError(ds, "upname_swap(NameToEnum): too few bytes (%d after header)\n" 480 " for pnames.icu NameToEnum[%d] at %d\n", 481 length, tempMap->count, pos); 482 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; 483 return 0; 484 } 485 } 486 487 /* swap count */ 488 ds->swapArray32(ds, inMap, 4, outMap, pErrorCode); 489 490 inEnumArray=inMap->getEnumArray(); 491 outEnumArray=outMap->getEnumArray(); 492 493 inNameArray=(const Offset *)(inEnumArray+tempMap->count); 494 outNameArray=(Offset *)(outEnumArray+tempMap->count); 495 496 if(ds->inCharset==ds->outCharset) { 497 /* no need to sort, just swap the enum/name arrays */ 498 ds->swapArray32(ds, inEnumArray, tempMap->count*4, outEnumArray, pErrorCode); 499 ds->swapArray16(ds, inNameArray, tempMap->count*2, outNameArray, pErrorCode); 500 return size; 501 } 502 503 /* 504 * The name and enum arrays are sorted by names and must be resorted 505 * if inCharset!=outCharset. 506 * We use the corresponding part of the temp array to sort an array 507 * of pairs of name offsets and sorting indexes. 508 * Then the sorting indexes are used to permutate-swap the name and enum arrays. 509 * 510 * The outBytes must already contain the swapped strings. 511 */ 512 sortArray=(NameAndIndex *)tempMap->getEnumArray(); 513 for(i=0; i<tempMap->count; ++i) { 514 sortArray[i].name=udata_readInt16(ds, inNameArray[i]); 515 sortArray[i].index=(Offset)i; 516 } 517 518 /* 519 * use a stable sort to avoid shuffling of equal strings, 520 * which makes testing harder 521 */ 522 cmp.chars=(const char *)outBytes; 523 if (ds->outCharset==U_ASCII_FAMILY) { 524 cmp.propCompare=uprv_compareASCIIPropertyNames; 525 } 526 else { 527 cmp.propCompare=uprv_compareEBCDICPropertyNames; 528 } 529 uprv_sortArray(sortArray, tempMap->count, sizeof(NameAndIndex), 530 upname_compareRows, &cmp, 531 TRUE, pErrorCode); 532 if(U_FAILURE(*pErrorCode)) { 533 udata_printError(ds, "upname_swap(NameToEnum).uprv_sortArray(%d items) failed\n", 534 tempMap->count); 535 return 0; 536 } 537 538 /* copy/swap/permutate _enumArray[] and _nameArray[] */ 539 if(inEnumArray!=outEnumArray) { 540 for(i=0; i<tempMap->count; ++i) { 541 oldIndex=sortArray[i].index; 542 ds->swapArray32(ds, inEnumArray+oldIndex, 4, outEnumArray+i, pErrorCode); 543 ds->swapArray16(ds, inNameArray+oldIndex, 2, outNameArray+i, pErrorCode); 544 } 545 } else { 546 /* 547 * in-place swapping: need to permutate into a temporary array 548 * and then copy back to not destroy the data 549 */ 550 EnumValue *tempEnumArray; 551 Offset *oldIndexes; 552 553 /* write name offsets directly from sortArray */ 554 for(i=0; i<tempMap->count; ++i) { 555 ds->writeUInt16((uint16_t *)outNameArray+i, (uint16_t)sortArray[i].name); 556 } 557 558 /* 559 * compress the oldIndexes into a separate array to make space for tempEnumArray 560 * the tempMap _nameArray becomes oldIndexes[], getting the index 561 * values from the 2D sortArray[], 562 * while sortArray=tempMap _enumArray[] becomes tempEnumArray[] 563 * this saves us allocating more memory 564 * 565 * it works because sizeof(NameAndIndex)<=sizeof(EnumValue) 566 * and because the nameArray[] can be used for oldIndexes[] 567 */ 568 tempEnumArray=(EnumValue *)sortArray; 569 oldIndexes=(Offset *)(sortArray+tempMap->count); 570 571 /* copy sortArray[].index values into oldIndexes[] */ 572 for(i=0; i<tempMap->count; ++i) { 573 oldIndexes[i]=sortArray[i].index; 574 } 575 576 /* permutate inEnumArray[] into tempEnumArray[] */ 577 for(i=0; i<tempMap->count; ++i) { 578 ds->swapArray32(ds, inEnumArray+oldIndexes[i], 4, tempEnumArray+i, pErrorCode); 579 } 580 581 /* copy tempEnumArray[] to outEnumArray[] */ 582 uprv_memcpy(outEnumArray, tempEnumArray, tempMap->count*4); 583 } 584 } 585 586 return size; 587 } 588 589 int32_t 590 PropertyAliases::swap(const UDataSwapper *ds, 591 const uint8_t *inBytes, int32_t length, uint8_t *outBytes, 592 UErrorCode *pErrorCode) { 593 const PropertyAliases *inAliases; 594 PropertyAliases *outAliases; 595 PropertyAliases aliases; 596 597 const ValueMap *inValueMaps; 598 ValueMap *outValueMaps; 599 ValueMap valueMap; 600 601 uint8_t *temp; 602 603 int32_t i; 604 605 inAliases=(const PropertyAliases *)inBytes; 606 outAliases=(PropertyAliases *)outBytes; 607 608 /* read the input PropertyAliases - all 16-bit values */ 609 for(i=0; i<(int32_t)sizeof(PropertyAliases)/2; ++i) { 610 ((uint16_t *)&aliases)[i]=ds->readUInt16(((const uint16_t *)inBytes)[i]); 611 } 612 613 if(length>=0) { 614 if(length<aliases.total_size) { 615 udata_printError(ds, "upname_swap(): too few bytes (%d after header) for all of pnames.icu\n", 616 length); 617 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; 618 return 0; 619 } 620 621 /* copy the data for inaccessible bytes */ 622 if(inBytes!=outBytes) { 623 uprv_memcpy(outBytes, inBytes, aliases.total_size); 624 } 625 626 /* swap the PropertyAliases class fields */ 627 ds->swapArray16(ds, inAliases, sizeof(PropertyAliases), outAliases, pErrorCode); 628 629 /* swap the name groups */ 630 ds->swapArray16(ds, inBytes+aliases.nameGroupPool_offset, 631 aliases.stringPool_offset-aliases.nameGroupPool_offset, 632 outBytes+aliases.nameGroupPool_offset, pErrorCode); 633 634 /* swap the strings */ 635 udata_swapInvStringBlock(ds, inBytes+aliases.stringPool_offset, 636 aliases.total_size-aliases.stringPool_offset, 637 outBytes+aliases.stringPool_offset, pErrorCode); 638 639 /* 640 * alloc uint8_t temp[total_size] and reset it 641 * swap each top-level struct, put at least the count fields into temp 642 * use subclass-specific swap() functions 643 * enumerate value maps, for each 644 * if temp does not have count!=0 yet 645 * read count, put it into temp 646 * swap the array(s) 647 * resort strings in name->enum maps 648 * swap value maps 649 */ 650 temp=(uint8_t *)uprv_malloc(aliases.total_size); 651 if(temp==NULL) { 652 udata_printError(ds, "upname_swap(): unable to allocate temp memory (%d bytes)\n", 653 aliases.total_size); 654 *pErrorCode=U_MEMORY_ALLOCATION_ERROR; 655 return 0; 656 } 657 uprv_memset(temp, 0, aliases.total_size); 658 659 /* swap properties->name groups map */ 660 NonContiguousEnumToOffset::swap(ds, inBytes, length, outBytes, 661 temp, aliases.enumToName_offset, pErrorCode); 662 663 /* swap name->properties map */ 664 NameToEnum::swap(ds, inBytes, length, outBytes, 665 temp, aliases.nameToEnum_offset, pErrorCode); 666 667 /* swap properties->value maps map */ 668 NonContiguousEnumToOffset::swap(ds, inBytes, length, outBytes, 669 temp, aliases.enumToValue_offset, pErrorCode); 670 671 /* enumerate all ValueMaps and swap them */ 672 inValueMaps=(const ValueMap *)(inBytes+aliases.valueMap_offset); 673 outValueMaps=(ValueMap *)(outBytes+aliases.valueMap_offset); 674 675 for(i=0; i<aliases.valueMap_count; ++i) { 676 valueMap.enumToName_offset=udata_readInt16(ds, inValueMaps[i].enumToName_offset); 677 valueMap.ncEnumToName_offset=udata_readInt16(ds, inValueMaps[i].ncEnumToName_offset); 678 valueMap.nameToEnum_offset=udata_readInt16(ds, inValueMaps[i].nameToEnum_offset); 679 680 if(valueMap.enumToName_offset!=0) { 681 EnumToOffset::swap(ds, inBytes, length, outBytes, 682 temp, valueMap.enumToName_offset, 683 pErrorCode); 684 } else if(valueMap.ncEnumToName_offset!=0) { 685 NonContiguousEnumToOffset::swap(ds, inBytes, length, outBytes, 686 temp, valueMap.ncEnumToName_offset, 687 pErrorCode); 688 } 689 if(valueMap.nameToEnum_offset!=0) { 690 NameToEnum::swap(ds, inBytes, length, outBytes, 691 temp, valueMap.nameToEnum_offset, 692 pErrorCode); 693 } 694 } 695 696 /* swap the ValueMaps array itself */ 697 ds->swapArray16(ds, inValueMaps, aliases.valueMap_count*sizeof(ValueMap), 698 outValueMaps, pErrorCode); 699 700 /* name groups and strings were swapped above */ 701 702 /* release temp */ 703 uprv_free(temp); 704 } 705 706 return aliases.total_size; 707 } 708 709 U_CAPI int32_t U_EXPORT2 710 upname_swap(const UDataSwapper *ds, 711 const void *inData, int32_t length, void *outData, 712 UErrorCode *pErrorCode) { 713 const UDataInfo *pInfo; 714 int32_t headerSize; 715 716 const uint8_t *inBytes; 717 uint8_t *outBytes; 718 719 /* udata_swapDataHeader checks the arguments */ 720 headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode); 721 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { 722 return 0; 723 } 724 725 /* check data format and format version */ 726 pInfo=(const UDataInfo *)((const char *)inData+4); 727 if(!( 728 pInfo->dataFormat[0]==0x70 && /* dataFormat="pnam" */ 729 pInfo->dataFormat[1]==0x6e && 730 pInfo->dataFormat[2]==0x61 && 731 pInfo->dataFormat[3]==0x6d && 732 pInfo->formatVersion[0]==1 733 )) { 734 udata_printError(ds, "upname_swap(): data format %02x.%02x.%02x.%02x (format version %02x) is not recognized as pnames.icu\n", 735 pInfo->dataFormat[0], pInfo->dataFormat[1], 736 pInfo->dataFormat[2], pInfo->dataFormat[3], 737 pInfo->formatVersion[0]); 738 *pErrorCode=U_UNSUPPORTED_ERROR; 739 return 0; 740 } 741 742 inBytes=(const uint8_t *)inData+headerSize; 743 outBytes=(uint8_t *)outData+headerSize; 744 745 if(length>=0) { 746 length-=headerSize; 747 if(length<(int32_t)sizeof(PropertyAliases)) { 748 udata_printError(ds, "upname_swap(): too few bytes (%d after header) for pnames.icu\n", 749 length); 750 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; 751 return 0; 752 } 753 } 754 755 return headerSize+PropertyAliases::swap(ds, inBytes, length, outBytes, pErrorCode); 756 } 757 758 //eof 759
