| /* | |
| ******************************************************************************* | |
| * | |
| * Copyright (C) 2000-2015, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| * | |
| ******************************************************************************* | |
| * | |
| * File reslist.cpp | |
| * | |
| * Modification History: | |
| * | |
| * Date Name Description | |
| * 02/21/00 weiv Creation. | |
| ******************************************************************************* | |
| */ | |
| // Safer use of UnicodeString. | |
| #ifndef UNISTR_FROM_CHAR_EXPLICIT | |
| # define UNISTR_FROM_CHAR_EXPLICIT explicit | |
| #endif | |
| // Less important, but still a good idea. | |
| #ifndef UNISTR_FROM_STRING_EXPLICIT | |
| # define UNISTR_FROM_STRING_EXPLICIT explicit | |
| #endif | |
| #include <assert.h> | |
| #include <stdio.h> | |
| #include "unicode/localpointer.h" | |
| #include "reslist.h" | |
| #include "unewdata.h" | |
| #include "unicode/ures.h" | |
| #include "unicode/putil.h" | |
| #include "errmsg.h" | |
| #include "uarrsort.h" | |
| #include "uelement.h" | |
| #include "uhash.h" | |
| #include "uinvchar.h" | |
| #include "ustr_imp.h" | |
| #include "unicode/utf16.h" | |
| /* | |
| * Align binary data at a 16-byte offset from the start of the resource bundle, | |
| * to be safe for any data type it may contain. | |
| */ | |
| #define BIN_ALIGNMENT 16 | |
| // This numeric constant must be at least 1. | |
| // If StringResource.fNumUnitsSaved == 0 then the string occurs only once, | |
| // and it makes no sense to move it to the pool bundle. | |
| // The larger the threshold for fNumUnitsSaved | |
| // the smaller the savings, and the smaller the pool bundle. | |
| // We trade some total size reduction to reduce the pool bundle a bit, | |
| // so that one can reasonably save data size by | |
| // removing bundle files without rebuilding the pool bundle. | |
| // This can also help to keep the pool and total (pool+local) string indexes | |
| // within 16 bits, that is, within range of Table16 and Array16 containers. | |
| #ifndef GENRB_MIN_16BIT_UNITS_SAVED_FOR_POOL_STRING | |
| # define GENRB_MIN_16BIT_UNITS_SAVED_FOR_POOL_STRING 10 | |
| #endif | |
| U_NAMESPACE_USE | |
| static UBool gIncludeCopyright = FALSE; | |
| static UBool gUsePoolBundle = FALSE; | |
| static UBool gIsDefaultFormatVersion = TRUE; | |
| static int32_t gFormatVersion = 3; | |
| /* How do we store string values? */ | |
| enum { | |
| STRINGS_UTF16_V1, /* formatVersion 1: int length + UChars + NUL + padding to 4 bytes */ | |
| STRINGS_UTF16_V2 /* formatVersion 2 & up: optional length in 1..3 UChars + UChars + NUL */ | |
| }; | |
| static const int32_t MAX_IMPLICIT_STRING_LENGTH = 40; /* do not store the length explicitly for such strings */ | |
| static const ResFile kNoPoolBundle; | |
| /* | |
| * res_none() returns the address of kNoResource, | |
| * for use in non-error cases when no resource is to be added to the bundle. | |
| * (NULL is used in error cases.) | |
| */ | |
| static SResource kNoResource; // TODO: const | |
| static UDataInfo dataInfo= { | |
| sizeof(UDataInfo), | |
| 0, | |
| U_IS_BIG_ENDIAN, | |
| U_CHARSET_FAMILY, | |
| sizeof(UChar), | |
| 0, | |
| {0x52, 0x65, 0x73, 0x42}, /* dataFormat="ResB" */ | |
| {1, 3, 0, 0}, /* formatVersion */ | |
| {1, 4, 0, 0} /* dataVersion take a look at version inside parsed resb*/ | |
| }; | |
| static const UVersionInfo gFormatVersions[4] = { /* indexed by a major-formatVersion integer */ | |
| { 0, 0, 0, 0 }, | |
| { 1, 3, 0, 0 }, | |
| { 2, 0, 0, 0 }, | |
| { 3, 0, 0, 0 } | |
| }; | |
| // Remember to update genrb.h GENRB_VERSION when changing the data format. | |
| // (Or maybe we should remove GENRB_VERSION and report the ICU version number?) | |
| static uint8_t calcPadding(uint32_t size) { | |
| /* returns space we need to pad */ | |
| return (uint8_t) ((size % sizeof(uint32_t)) ? (sizeof(uint32_t) - (size % sizeof(uint32_t))) : 0); | |
| } | |
| void setIncludeCopyright(UBool val){ | |
| gIncludeCopyright=val; | |
| } | |
| UBool getIncludeCopyright(void){ | |
| return gIncludeCopyright; | |
| } | |
| void setFormatVersion(int32_t formatVersion) { | |
| gIsDefaultFormatVersion = FALSE; | |
| gFormatVersion = formatVersion; | |
| } | |
| int32_t getFormatVersion() { | |
| return gFormatVersion; | |
| } | |
| void setUsePoolBundle(UBool use) { | |
| gUsePoolBundle = use; | |
| } | |
| // TODO: return const pointer, or find another way to express "none" | |
| struct SResource* res_none() { | |
| return &kNoResource; | |
| } | |
| SResource::SResource() | |
| : fType(URES_NONE), fWritten(FALSE), fRes(RES_BOGUS), fRes16(-1), fKey(-1), fKey16(-1), | |
| line(0), fNext(NULL) { | |
| ustr_init(&fComment); | |
| } | |
| SResource::SResource(SRBRoot *bundle, const char *tag, int8_t type, const UString* comment, | |
| UErrorCode &errorCode) | |
| : fType(type), fWritten(FALSE), fRes(RES_BOGUS), fRes16(-1), | |
| fKey(bundle != NULL ? bundle->addTag(tag, errorCode) : -1), fKey16(-1), | |
| line(0), fNext(NULL) { | |
| ustr_init(&fComment); | |
| if(comment != NULL) { | |
| ustr_cpy(&fComment, comment, &errorCode); | |
| } | |
| } | |
| SResource::~SResource() { | |
| ustr_deinit(&fComment); | |
| } | |
| ContainerResource::~ContainerResource() { | |
| SResource *current = fFirst; | |
| while (current != NULL) { | |
| SResource *next = current->fNext; | |
| delete current; | |
| current = next; | |
| } | |
| } | |
| TableResource::~TableResource() {} | |
| // TODO: clarify that containers adopt new items, even in error cases; use LocalPointer | |
| void TableResource::add(SResource *res, int linenumber, UErrorCode &errorCode) { | |
| if (U_FAILURE(errorCode) || res == NULL || res == &kNoResource) { | |
| return; | |
| } | |
| /* remember this linenumber to report to the user if there is a duplicate key */ | |
| res->line = linenumber; | |
| /* here we need to traverse the list */ | |
| ++fCount; | |
| /* is the list still empty? */ | |
| if (fFirst == NULL) { | |
| fFirst = res; | |
| res->fNext = NULL; | |
| return; | |
| } | |
| const char *resKeyString = fRoot->fKeys + res->fKey; | |
| SResource *current = fFirst; | |
| SResource *prev = NULL; | |
| while (current != NULL) { | |
| const char *currentKeyString = fRoot->fKeys + current->fKey; | |
| int diff; | |
| /* | |
| * formatVersion 1: compare key strings in native-charset order | |
| * formatVersion 2 and up: compare key strings in ASCII order | |
| */ | |
| if (gFormatVersion == 1 || U_CHARSET_FAMILY == U_ASCII_FAMILY) { | |
| diff = uprv_strcmp(currentKeyString, resKeyString); | |
| } else { | |
| diff = uprv_compareInvCharsAsAscii(currentKeyString, resKeyString); | |
| } | |
| if (diff < 0) { | |
| prev = current; | |
| current = current->fNext; | |
| } else if (diff > 0) { | |
| /* we're either in front of the list, or in the middle */ | |
| if (prev == NULL) { | |
| /* front of the list */ | |
| fFirst = res; | |
| } else { | |
| /* middle of the list */ | |
| prev->fNext = res; | |
| } | |
| res->fNext = current; | |
| return; | |
| } else { | |
| /* Key already exists! ERROR! */ | |
| error(linenumber, "duplicate key '%s' in table, first appeared at line %d", currentKeyString, current->line); | |
| errorCode = U_UNSUPPORTED_ERROR; | |
| return; | |
| } | |
| } | |
| /* end of list */ | |
| prev->fNext = res; | |
| res->fNext = NULL; | |
| } | |
| ArrayResource::~ArrayResource() {} | |
| void ArrayResource::add(SResource *res) { | |
| if (res != NULL && res != &kNoResource) { | |
| if (fFirst == NULL) { | |
| fFirst = res; | |
| } else { | |
| fLast->fNext = res; | |
| } | |
| fLast = res; | |
| ++fCount; | |
| } | |
| } | |
| PseudoListResource::~PseudoListResource() {} | |
| void PseudoListResource::add(SResource *res) { | |
| if (res != NULL && res != &kNoResource) { | |
| res->fNext = fFirst; | |
| fFirst = res; | |
| ++fCount; | |
| } | |
| } | |
| StringBaseResource::StringBaseResource(SRBRoot *bundle, const char *tag, int8_t type, | |
| const UChar *value, int32_t len, | |
| const UString* comment, UErrorCode &errorCode) | |
| : SResource(bundle, tag, type, comment, errorCode) { | |
| if (len == 0 && gFormatVersion > 1) { | |
| fRes = URES_MAKE_EMPTY_RESOURCE(type); | |
| fWritten = TRUE; | |
| return; | |
| } | |
| fString.setTo(value, len); | |
| fString.getTerminatedBuffer(); // Some code relies on NUL-termination. | |
| if (U_SUCCESS(errorCode) && fString.isBogus()) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| } | |
| StringBaseResource::StringBaseResource(SRBRoot *bundle, int8_t type, | |
| const icu::UnicodeString &value, UErrorCode &errorCode) | |
| : SResource(bundle, NULL, type, NULL, errorCode), fString(value) { | |
| if (value.isEmpty() && gFormatVersion > 1) { | |
| fRes = URES_MAKE_EMPTY_RESOURCE(type); | |
| fWritten = TRUE; | |
| return; | |
| } | |
| fString.getTerminatedBuffer(); // Some code relies on NUL-termination. | |
| if (U_SUCCESS(errorCode) && fString.isBogus()) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| } | |
| // Pool bundle string, alias the buffer. Guaranteed NUL-terminated and not empty. | |
| StringBaseResource::StringBaseResource(int8_t type, const UChar *value, int32_t len, | |
| UErrorCode &errorCode) | |
| : SResource(NULL, NULL, type, NULL, errorCode), fString(TRUE, value, len) { | |
| assert(len > 0); | |
| assert(!fString.isBogus()); | |
| } | |
| StringBaseResource::~StringBaseResource() {} | |
| static int32_t U_CALLCONV | |
| string_hash(const UElement key) { | |
| const StringResource *res = static_cast<const StringResource *>(key.pointer); | |
| return res->fString.hashCode(); | |
| } | |
| static UBool U_CALLCONV | |
| string_comp(const UElement key1, const UElement key2) { | |
| const StringResource *res1 = static_cast<const StringResource *>(key1.pointer); | |
| const StringResource *res2 = static_cast<const StringResource *>(key2.pointer); | |
| return res1->fString == res2->fString; | |
| } | |
| StringResource::~StringResource() {} | |
| AliasResource::~AliasResource() {} | |
| IntResource::IntResource(SRBRoot *bundle, const char *tag, int32_t value, | |
| const UString* comment, UErrorCode &errorCode) | |
| : SResource(bundle, tag, URES_INT, comment, errorCode) { | |
| fValue = value; | |
| fRes = URES_MAKE_RESOURCE(URES_INT, value & RES_MAX_OFFSET); | |
| fWritten = TRUE; | |
| } | |
| IntResource::~IntResource() {} | |
| IntVectorResource::IntVectorResource(SRBRoot *bundle, const char *tag, | |
| const UString* comment, UErrorCode &errorCode) | |
| : SResource(bundle, tag, URES_INT_VECTOR, comment, errorCode), | |
| fCount(0), fArray(new uint32_t[RESLIST_MAX_INT_VECTOR]) { | |
| if (fArray == NULL) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| } | |
| IntVectorResource::~IntVectorResource() { | |
| delete[] fArray; | |
| } | |
| void IntVectorResource::add(int32_t value, UErrorCode &errorCode) { | |
| if (U_SUCCESS(errorCode)) { | |
| fArray[fCount++] = value; | |
| } | |
| } | |
| BinaryResource::BinaryResource(SRBRoot *bundle, const char *tag, | |
| uint32_t length, uint8_t *data, const char* fileName, | |
| const UString* comment, UErrorCode &errorCode) | |
| : SResource(bundle, tag, URES_BINARY, comment, errorCode), | |
| fLength(length), fData(NULL), fFileName(NULL) { | |
| if (U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| if (fileName != NULL && *fileName != 0){ | |
| fFileName = new char[uprv_strlen(fileName)+1]; | |
| if (fFileName == NULL) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| uprv_strcpy(fFileName, fileName); | |
| } | |
| if (length > 0) { | |
| fData = new uint8_t[length]; | |
| if (fData == NULL) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| uprv_memcpy(fData, data, length); | |
| } else { | |
| if (gFormatVersion > 1) { | |
| fRes = URES_MAKE_EMPTY_RESOURCE(URES_BINARY); | |
| fWritten = TRUE; | |
| } | |
| } | |
| } | |
| BinaryResource::~BinaryResource() { | |
| delete[] fData; | |
| delete[] fFileName; | |
| } | |
| /* Writing Functions */ | |
| void | |
| StringResource::handlePreflightStrings(SRBRoot *bundle, UHashtable *stringSet, | |
| UErrorCode &errorCode) { | |
| assert(fSame == NULL); | |
| fSame = static_cast<StringResource *>(uhash_get(stringSet, this)); | |
| if (fSame != NULL) { | |
| // This is a duplicate of a pool bundle string or of an earlier-visited string. | |
| if (++fSame->fNumCopies == 1) { | |
| assert(fSame->fWritten); | |
| int32_t poolStringIndex = (int32_t)RES_GET_OFFSET(fSame->fRes); | |
| if (poolStringIndex >= bundle->fPoolStringIndexLimit) { | |
| bundle->fPoolStringIndexLimit = poolStringIndex + 1; | |
| } | |
| } | |
| return; | |
| } | |
| /* Put this string into the set for finding duplicates. */ | |
| fNumCopies = 1; | |
| uhash_put(stringSet, this, this, &errorCode); | |
| if (bundle->fStringsForm != STRINGS_UTF16_V1) { | |
| int32_t len = length(); | |
| if (len <= MAX_IMPLICIT_STRING_LENGTH && | |
| !U16_IS_TRAIL(fString[0]) && fString.indexOf((UChar)0) < 0) { | |
| /* | |
| * This string will be stored without an explicit length. | |
| * Runtime will detect !U16_IS_TRAIL(s[0]) and call u_strlen(). | |
| */ | |
| fNumCharsForLength = 0; | |
| } else if (len <= 0x3ee) { | |
| fNumCharsForLength = 1; | |
| } else if (len <= 0xfffff) { | |
| fNumCharsForLength = 2; | |
| } else { | |
| fNumCharsForLength = 3; | |
| } | |
| bundle->f16BitStringsLength += fNumCharsForLength + len + 1; /* +1 for the NUL */ | |
| } | |
| } | |
| void | |
| ContainerResource::handlePreflightStrings(SRBRoot *bundle, UHashtable *stringSet, | |
| UErrorCode &errorCode) { | |
| for (SResource *current = fFirst; current != NULL; current = current->fNext) { | |
| current->preflightStrings(bundle, stringSet, errorCode); | |
| } | |
| } | |
| void | |
| SResource::preflightStrings(SRBRoot *bundle, UHashtable *stringSet, UErrorCode &errorCode) { | |
| if (U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| if (fRes != RES_BOGUS) { | |
| /* | |
| * The resource item word was already precomputed, which means | |
| * no further data needs to be written. | |
| * This might be an integer, or an empty string/binary/etc. | |
| */ | |
| return; | |
| } | |
| handlePreflightStrings(bundle, stringSet, errorCode); | |
| } | |
| void | |
| SResource::handlePreflightStrings(SRBRoot * /*bundle*/, UHashtable * /*stringSet*/, | |
| UErrorCode & /*errorCode*/) { | |
| /* Neither a string nor a container. */ | |
| } | |
| int32_t | |
| SRBRoot::makeRes16(uint32_t resWord) const { | |
| if (resWord == 0) { | |
| return 0; /* empty string */ | |
| } | |
| uint32_t type = RES_GET_TYPE(resWord); | |
| int32_t offset = (int32_t)RES_GET_OFFSET(resWord); | |
| if (type == URES_STRING_V2) { | |
| assert(offset > 0); | |
| if (offset < fPoolStringIndexLimit) { | |
| if (offset < fPoolStringIndex16Limit) { | |
| return offset; | |
| } | |
| } else { | |
| offset = offset - fPoolStringIndexLimit + fPoolStringIndex16Limit; | |
| if (offset <= 0xffff) { | |
| return offset; | |
| } | |
| } | |
| } | |
| return -1; | |
| } | |
| int32_t | |
| SRBRoot::mapKey(int32_t oldpos) const { | |
| const KeyMapEntry *map = fKeyMap; | |
| if (map == NULL) { | |
| return oldpos; | |
| } | |
| int32_t i, start, limit; | |
| /* do a binary search for the old, pre-compactKeys() key offset */ | |
| start = fUsePoolBundle->fKeysCount; | |
| limit = start + fKeysCount; | |
| while (start < limit - 1) { | |
| i = (start + limit) / 2; | |
| if (oldpos < map[i].oldpos) { | |
| limit = i; | |
| } else { | |
| start = i; | |
| } | |
| } | |
| assert(oldpos == map[start].oldpos); | |
| return map[start].newpos; | |
| } | |
| /* | |
| * Only called for UTF-16 v1 strings and duplicate UTF-16 v2 strings. | |
| * For unique UTF-16 v2 strings, write16() sees fRes != RES_BOGUS | |
| * and exits early. | |
| */ | |
| void | |
| StringResource::handleWrite16(SRBRoot * /*bundle*/) { | |
| SResource *same; | |
| if ((same = fSame) != NULL) { | |
| /* This is a duplicate. */ | |
| assert(same->fRes != RES_BOGUS && same->fWritten); | |
| fRes = same->fRes; | |
| fWritten = same->fWritten; | |
| } | |
| } | |
| void | |
| ContainerResource::writeAllRes16(SRBRoot *bundle) { | |
| for (SResource *current = fFirst; current != NULL; current = current->fNext) { | |
| bundle->f16BitUnits.append((UChar)current->fRes16); | |
| } | |
| fWritten = TRUE; | |
| } | |
| void | |
| ArrayResource::handleWrite16(SRBRoot *bundle) { | |
| if (fCount == 0 && gFormatVersion > 1) { | |
| fRes = URES_MAKE_EMPTY_RESOURCE(URES_ARRAY); | |
| fWritten = TRUE; | |
| return; | |
| } | |
| int32_t res16 = 0; | |
| for (SResource *current = fFirst; current != NULL; current = current->fNext) { | |
| current->write16(bundle); | |
| res16 |= current->fRes16; | |
| } | |
| if (fCount <= 0xffff && res16 >= 0 && gFormatVersion > 1) { | |
| fRes = URES_MAKE_RESOURCE(URES_ARRAY16, bundle->f16BitUnits.length()); | |
| bundle->f16BitUnits.append((UChar)fCount); | |
| writeAllRes16(bundle); | |
| } | |
| } | |
| void | |
| TableResource::handleWrite16(SRBRoot *bundle) { | |
| if (fCount == 0 && gFormatVersion > 1) { | |
| fRes = URES_MAKE_EMPTY_RESOURCE(URES_TABLE); | |
| fWritten = TRUE; | |
| return; | |
| } | |
| /* Find the smallest table type that fits the data. */ | |
| int32_t key16 = 0; | |
| int32_t res16 = 0; | |
| for (SResource *current = fFirst; current != NULL; current = current->fNext) { | |
| current->write16(bundle); | |
| key16 |= current->fKey16; | |
| res16 |= current->fRes16; | |
| } | |
| if(fCount > (uint32_t)bundle->fMaxTableLength) { | |
| bundle->fMaxTableLength = fCount; | |
| } | |
| if (fCount <= 0xffff && key16 >= 0) { | |
| if (res16 >= 0 && gFormatVersion > 1) { | |
| /* 16-bit count, key offsets and values */ | |
| fRes = URES_MAKE_RESOURCE(URES_TABLE16, bundle->f16BitUnits.length()); | |
| bundle->f16BitUnits.append((UChar)fCount); | |
| for (SResource *current = fFirst; current != NULL; current = current->fNext) { | |
| bundle->f16BitUnits.append((UChar)current->fKey16); | |
| } | |
| writeAllRes16(bundle); | |
| } else { | |
| /* 16-bit count, 16-bit key offsets, 32-bit values */ | |
| fTableType = URES_TABLE; | |
| } | |
| } else { | |
| /* 32-bit count, key offsets and values */ | |
| fTableType = URES_TABLE32; | |
| } | |
| } | |
| void | |
| PseudoListResource::handleWrite16(SRBRoot * /*bundle*/) { | |
| fRes = URES_MAKE_EMPTY_RESOURCE(URES_TABLE); | |
| fWritten = TRUE; | |
| } | |
| void | |
| SResource::write16(SRBRoot *bundle) { | |
| if (fKey >= 0) { | |
| // A tagged resource has a non-negative key index into the parsed key strings. | |
| // compactKeys() built a map from parsed key index to the final key index. | |
| // After the mapping, negative key indexes are used for shared pool bundle keys. | |
| fKey = bundle->mapKey(fKey); | |
| // If the key index fits into a Key16 for a Table or Table16, | |
| // then set the fKey16 field accordingly. | |
| // Otherwise keep it at -1. | |
| if (fKey >= 0) { | |
| if (fKey < bundle->fLocalKeyLimit) { | |
| fKey16 = fKey; | |
| } | |
| } else { | |
| int32_t poolKeyIndex = fKey & 0x7fffffff; | |
| if (poolKeyIndex <= 0xffff) { | |
| poolKeyIndex += bundle->fLocalKeyLimit; | |
| if (poolKeyIndex <= 0xffff) { | |
| fKey16 = poolKeyIndex; | |
| } | |
| } | |
| } | |
| } | |
| /* | |
| * fRes != RES_BOGUS: | |
| * The resource item word was already precomputed, which means | |
| * no further data needs to be written. | |
| * This might be an integer, or an empty or UTF-16 v2 string, | |
| * an empty binary, etc. | |
| */ | |
| if (fRes == RES_BOGUS) { | |
| handleWrite16(bundle); | |
| } | |
| // Compute fRes16 for precomputed as well as just-computed fRes. | |
| fRes16 = bundle->makeRes16(fRes); | |
| } | |
| void | |
| SResource::handleWrite16(SRBRoot * /*bundle*/) { | |
| /* Only a few resource types write 16-bit units. */ | |
| } | |
| /* | |
| * Only called for UTF-16 v1 strings, and for aliases. | |
| * For UTF-16 v2 strings, preWrite() sees fRes != RES_BOGUS | |
| * and exits early. | |
| */ | |
| void | |
| StringBaseResource::handlePreWrite(uint32_t *byteOffset) { | |
| /* Write the UTF-16 v1 string. */ | |
| fRes = URES_MAKE_RESOURCE(fType, *byteOffset >> 2); | |
| *byteOffset += 4 + (length() + 1) * U_SIZEOF_UCHAR; | |
| } | |
| void | |
| IntVectorResource::handlePreWrite(uint32_t *byteOffset) { | |
| if (fCount == 0 && gFormatVersion > 1) { | |
| fRes = URES_MAKE_EMPTY_RESOURCE(URES_INT_VECTOR); | |
| fWritten = TRUE; | |
| } else { | |
| fRes = URES_MAKE_RESOURCE(URES_INT_VECTOR, *byteOffset >> 2); | |
| *byteOffset += (1 + fCount) * 4; | |
| } | |
| } | |
| void | |
| BinaryResource::handlePreWrite(uint32_t *byteOffset) { | |
| uint32_t pad = 0; | |
| uint32_t dataStart = *byteOffset + sizeof(fLength); | |
| if (dataStart % BIN_ALIGNMENT) { | |
| pad = (BIN_ALIGNMENT - dataStart % BIN_ALIGNMENT); | |
| *byteOffset += pad; /* pad == 4 or 8 or 12 */ | |
| } | |
| fRes = URES_MAKE_RESOURCE(URES_BINARY, *byteOffset >> 2); | |
| *byteOffset += 4 + fLength; | |
| } | |
| void | |
| ContainerResource::preWriteAllRes(uint32_t *byteOffset) { | |
| for (SResource *current = fFirst; current != NULL; current = current->fNext) { | |
| current->preWrite(byteOffset); | |
| } | |
| } | |
| void | |
| ArrayResource::handlePreWrite(uint32_t *byteOffset) { | |
| preWriteAllRes(byteOffset); | |
| fRes = URES_MAKE_RESOURCE(URES_ARRAY, *byteOffset >> 2); | |
| *byteOffset += (1 + fCount) * 4; | |
| } | |
| void | |
| TableResource::handlePreWrite(uint32_t *byteOffset) { | |
| preWriteAllRes(byteOffset); | |
| if (fTableType == URES_TABLE) { | |
| /* 16-bit count, 16-bit key offsets, 32-bit values */ | |
| fRes = URES_MAKE_RESOURCE(URES_TABLE, *byteOffset >> 2); | |
| *byteOffset += 2 + fCount * 6; | |
| } else { | |
| /* 32-bit count, key offsets and values */ | |
| fRes = URES_MAKE_RESOURCE(URES_TABLE32, *byteOffset >> 2); | |
| *byteOffset += 4 + fCount * 8; | |
| } | |
| } | |
| void | |
| SResource::preWrite(uint32_t *byteOffset) { | |
| if (fRes != RES_BOGUS) { | |
| /* | |
| * The resource item word was already precomputed, which means | |
| * no further data needs to be written. | |
| * This might be an integer, or an empty or UTF-16 v2 string, | |
| * an empty binary, etc. | |
| */ | |
| return; | |
| } | |
| handlePreWrite(byteOffset); | |
| *byteOffset += calcPadding(*byteOffset); | |
| } | |
| void | |
| SResource::handlePreWrite(uint32_t * /*byteOffset*/) { | |
| assert(FALSE); | |
| } | |
| /* | |
| * Only called for UTF-16 v1 strings, and for aliases. For UTF-16 v2 strings, | |
| * write() sees fWritten and exits early. | |
| */ | |
| void | |
| StringBaseResource::handleWrite(UNewDataMemory *mem, uint32_t *byteOffset) { | |
| /* Write the UTF-16 v1 string. */ | |
| int32_t len = length(); | |
| udata_write32(mem, len); | |
| udata_writeUString(mem, getBuffer(), len + 1); | |
| *byteOffset += 4 + (len + 1) * U_SIZEOF_UCHAR; | |
| fWritten = TRUE; | |
| } | |
| void | |
| ContainerResource::writeAllRes(UNewDataMemory *mem, uint32_t *byteOffset) { | |
| uint32_t i = 0; | |
| for (SResource *current = fFirst; current != NULL; ++i, current = current->fNext) { | |
| current->write(mem, byteOffset); | |
| } | |
| assert(i == fCount); | |
| } | |
| void | |
| ContainerResource::writeAllRes32(UNewDataMemory *mem, uint32_t *byteOffset) { | |
| for (SResource *current = fFirst; current != NULL; current = current->fNext) { | |
| udata_write32(mem, current->fRes); | |
| } | |
| *byteOffset += fCount * 4; | |
| } | |
| void | |
| ArrayResource::handleWrite(UNewDataMemory *mem, uint32_t *byteOffset) { | |
| writeAllRes(mem, byteOffset); | |
| udata_write32(mem, fCount); | |
| *byteOffset += 4; | |
| writeAllRes32(mem, byteOffset); | |
| } | |
| void | |
| IntVectorResource::handleWrite(UNewDataMemory *mem, uint32_t *byteOffset) { | |
| udata_write32(mem, fCount); | |
| for(uint32_t i = 0; i < fCount; ++i) { | |
| udata_write32(mem, fArray[i]); | |
| } | |
| *byteOffset += (1 + fCount) * 4; | |
| } | |
| void | |
| BinaryResource::handleWrite(UNewDataMemory *mem, uint32_t *byteOffset) { | |
| uint32_t pad = 0; | |
| uint32_t dataStart = *byteOffset + sizeof(fLength); | |
| if (dataStart % BIN_ALIGNMENT) { | |
| pad = (BIN_ALIGNMENT - dataStart % BIN_ALIGNMENT); | |
| udata_writePadding(mem, pad); /* pad == 4 or 8 or 12 */ | |
| *byteOffset += pad; | |
| } | |
| udata_write32(mem, fLength); | |
| if (fLength > 0) { | |
| udata_writeBlock(mem, fData, fLength); | |
| } | |
| *byteOffset += 4 + fLength; | |
| } | |
| void | |
| TableResource::handleWrite(UNewDataMemory *mem, uint32_t *byteOffset) { | |
| writeAllRes(mem, byteOffset); | |
| if(fTableType == URES_TABLE) { | |
| udata_write16(mem, (uint16_t)fCount); | |
| for (SResource *current = fFirst; current != NULL; current = current->fNext) { | |
| udata_write16(mem, current->fKey16); | |
| } | |
| *byteOffset += (1 + fCount)* 2; | |
| if ((fCount & 1) == 0) { | |
| /* 16-bit count and even number of 16-bit key offsets need padding before 32-bit resource items */ | |
| udata_writePadding(mem, 2); | |
| *byteOffset += 2; | |
| } | |
| } else /* URES_TABLE32 */ { | |
| udata_write32(mem, fCount); | |
| for (SResource *current = fFirst; current != NULL; current = current->fNext) { | |
| udata_write32(mem, (uint32_t)current->fKey); | |
| } | |
| *byteOffset += (1 + fCount)* 4; | |
| } | |
| writeAllRes32(mem, byteOffset); | |
| } | |
| void | |
| SResource::write(UNewDataMemory *mem, uint32_t *byteOffset) { | |
| if (fWritten) { | |
| assert(fRes != RES_BOGUS); | |
| return; | |
| } | |
| handleWrite(mem, byteOffset); | |
| uint8_t paddingSize = calcPadding(*byteOffset); | |
| if (paddingSize > 0) { | |
| udata_writePadding(mem, paddingSize); | |
| *byteOffset += paddingSize; | |
| } | |
| fWritten = TRUE; | |
| } | |
| void | |
| SResource::handleWrite(UNewDataMemory * /*mem*/, uint32_t * /*byteOffset*/) { | |
| assert(FALSE); | |
| } | |
| void SRBRoot::write(const char *outputDir, const char *outputPkg, | |
| char *writtenFilename, int writtenFilenameLen, | |
| UErrorCode &errorCode) { | |
| UNewDataMemory *mem = NULL; | |
| uint32_t byteOffset = 0; | |
| uint32_t top, size; | |
| char dataName[1024]; | |
| int32_t indexes[URES_INDEX_TOP]; | |
| compactKeys(errorCode); | |
| /* | |
| * Add padding bytes to fKeys so that fKeysTop is 4-aligned. | |
| * Safe because the capacity is a multiple of 4. | |
| */ | |
| while (fKeysTop & 3) { | |
| fKeys[fKeysTop++] = (char)0xaa; | |
| } | |
| /* | |
| * In URES_TABLE, use all local key offsets that fit into 16 bits, | |
| * and use the remaining 16-bit offsets for pool key offsets | |
| * if there are any. | |
| * If there are no local keys, then use the whole 16-bit space | |
| * for pool key offsets. | |
| * Note: This cannot be changed without changing the major formatVersion. | |
| */ | |
| if (fKeysBottom < fKeysTop) { | |
| if (fKeysTop <= 0x10000) { | |
| fLocalKeyLimit = fKeysTop; | |
| } else { | |
| fLocalKeyLimit = 0x10000; | |
| } | |
| } else { | |
| fLocalKeyLimit = 0; | |
| } | |
| UHashtable *stringSet; | |
| if (gFormatVersion > 1) { | |
| stringSet = uhash_open(string_hash, string_comp, string_comp, &errorCode); | |
| if (U_SUCCESS(errorCode) && | |
| fUsePoolBundle != NULL && fUsePoolBundle->fStrings != NULL) { | |
| for (SResource *current = fUsePoolBundle->fStrings->fFirst; | |
| current != NULL; | |
| current = current->fNext) { | |
| StringResource *sr = static_cast<StringResource *>(current); | |
| sr->fNumCopies = 0; | |
| sr->fNumUnitsSaved = 0; | |
| uhash_put(stringSet, sr, sr, &errorCode); | |
| } | |
| } | |
| fRoot->preflightStrings(this, stringSet, errorCode); | |
| } else { | |
| stringSet = NULL; | |
| } | |
| if (fStringsForm == STRINGS_UTF16_V2 && f16BitStringsLength > 0) { | |
| compactStringsV2(stringSet, errorCode); | |
| } | |
| uhash_close(stringSet); | |
| if (U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| int32_t formatVersion = gFormatVersion; | |
| if (fPoolStringIndexLimit != 0) { | |
| int32_t sum = fPoolStringIndexLimit + fLocalStringIndexLimit; | |
| if ((sum - 1) > RES_MAX_OFFSET) { | |
| errorCode = U_BUFFER_OVERFLOW_ERROR; | |
| return; | |
| } | |
| if (fPoolStringIndexLimit < 0x10000 && sum <= 0x10000) { | |
| // 16-bit indexes work for all pool + local strings. | |
| fPoolStringIndex16Limit = fPoolStringIndexLimit; | |
| } else { | |
| // Set the pool index threshold so that 16-bit indexes work | |
| // for some pool strings and some local strings. | |
| fPoolStringIndex16Limit = (int32_t)( | |
| ((int64_t)fPoolStringIndexLimit * 0xffff) / sum); | |
| } | |
| } else if (gIsDefaultFormatVersion && formatVersion == 3 && !fIsPoolBundle) { | |
| // If we just default to formatVersion 3 | |
| // but there are no pool bundle strings to share | |
| // and we do not write a pool bundle, | |
| // then write formatVersion 2 which is just as good. | |
| formatVersion = 2; | |
| } | |
| fRoot->write16(this); | |
| if (f16BitUnits.isBogus()) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| if (f16BitUnits.length() & 1) { | |
| f16BitUnits.append((UChar)0xaaaa); /* pad to multiple of 4 bytes */ | |
| } | |
| /* all keys have been mapped */ | |
| uprv_free(fKeyMap); | |
| fKeyMap = NULL; | |
| byteOffset = fKeysTop + f16BitUnits.length() * 2; | |
| fRoot->preWrite(&byteOffset); | |
| /* total size including the root item */ | |
| top = byteOffset; | |
| if (writtenFilename && writtenFilenameLen) { | |
| *writtenFilename = 0; | |
| } | |
| if (writtenFilename) { | |
| int32_t off = 0, len = 0; | |
| if (outputDir) { | |
| len = (int32_t)uprv_strlen(outputDir); | |
| if (len > writtenFilenameLen) { | |
| len = writtenFilenameLen; | |
| } | |
| uprv_strncpy(writtenFilename, outputDir, len); | |
| } | |
| if (writtenFilenameLen -= len) { | |
| off += len; | |
| writtenFilename[off] = U_FILE_SEP_CHAR; | |
| if (--writtenFilenameLen) { | |
| ++off; | |
| if(outputPkg != NULL) | |
| { | |
| uprv_strcpy(writtenFilename+off, outputPkg); | |
| off += (int32_t)uprv_strlen(outputPkg); | |
| writtenFilename[off] = '_'; | |
| ++off; | |
| } | |
| len = (int32_t)uprv_strlen(fLocale); | |
| if (len > writtenFilenameLen) { | |
| len = writtenFilenameLen; | |
| } | |
| uprv_strncpy(writtenFilename + off, fLocale, len); | |
| if (writtenFilenameLen -= len) { | |
| off += len; | |
| len = 5; | |
| if (len > writtenFilenameLen) { | |
| len = writtenFilenameLen; | |
| } | |
| uprv_strncpy(writtenFilename + off, ".res", len); | |
| } | |
| } | |
| } | |
| } | |
| if(outputPkg) | |
| { | |
| uprv_strcpy(dataName, outputPkg); | |
| uprv_strcat(dataName, "_"); | |
| uprv_strcat(dataName, fLocale); | |
| } | |
| else | |
| { | |
| uprv_strcpy(dataName, fLocale); | |
| } | |
| uprv_memcpy(dataInfo.formatVersion, gFormatVersions + formatVersion, sizeof(UVersionInfo)); | |
| mem = udata_create(outputDir, "res", dataName, | |
| &dataInfo, (gIncludeCopyright==TRUE)? U_COPYRIGHT_STRING:NULL, &errorCode); | |
| if(U_FAILURE(errorCode)){ | |
| return; | |
| } | |
| /* write the root item */ | |
| udata_write32(mem, fRoot->fRes); | |
| /* | |
| * formatVersion 1.1 (ICU 2.8): | |
| * write int32_t indexes[] after root and before the key strings | |
| * to make it easier to parse resource bundles in icuswap or from Java etc. | |
| */ | |
| uprv_memset(indexes, 0, sizeof(indexes)); | |
| indexes[URES_INDEX_LENGTH]= fIndexLength; | |
| indexes[URES_INDEX_KEYS_TOP]= fKeysTop>>2; | |
| indexes[URES_INDEX_RESOURCES_TOP]= (int32_t)(top>>2); | |
| indexes[URES_INDEX_BUNDLE_TOP]= indexes[URES_INDEX_RESOURCES_TOP]; | |
| indexes[URES_INDEX_MAX_TABLE_LENGTH]= fMaxTableLength; | |
| /* | |
| * formatVersion 1.2 (ICU 3.6): | |
| * write indexes[URES_INDEX_ATTRIBUTES] with URES_ATT_NO_FALLBACK set or not set | |
| * the memset() above initialized all indexes[] to 0 | |
| */ | |
| if (fNoFallback) { | |
| indexes[URES_INDEX_ATTRIBUTES]=URES_ATT_NO_FALLBACK; | |
| } | |
| /* | |
| * formatVersion 2.0 (ICU 4.4): | |
| * more compact string value storage, optional pool bundle | |
| */ | |
| if (URES_INDEX_16BIT_TOP < fIndexLength) { | |
| indexes[URES_INDEX_16BIT_TOP] = (fKeysTop>>2) + (f16BitUnits.length()>>1); | |
| } | |
| if (URES_INDEX_POOL_CHECKSUM < fIndexLength) { | |
| if (fIsPoolBundle) { | |
| indexes[URES_INDEX_ATTRIBUTES] |= URES_ATT_IS_POOL_BUNDLE | URES_ATT_NO_FALLBACK; | |
| uint32_t checksum = computeCRC((const char *)(fKeys + fKeysBottom), | |
| (uint32_t)(fKeysTop - fKeysBottom), 0); | |
| if (f16BitUnits.length() <= 1) { | |
| // no pool strings to checksum | |
| } else if (U_IS_BIG_ENDIAN) { | |
| checksum = computeCRC((const char *)f16BitUnits.getBuffer(), | |
| (uint32_t)f16BitUnits.length() * 2, checksum); | |
| } else { | |
| // Swap to big-endian so we get the same checksum on all platforms | |
| // (except for charset family, due to the key strings). | |
| UnicodeString s(f16BitUnits); | |
| s.append((UChar)1); // Ensure that we own this buffer. | |
| assert(!s.isBogus()); | |
| uint16_t *p = (uint16_t *)s.getBuffer(); | |
| for (int32_t count = f16BitUnits.length(); count > 0; --count) { | |
| uint16_t x = *p; | |
| *p++ = (uint16_t)((x << 8) | (x >> 8)); | |
| } | |
| checksum = computeCRC((const char *)p, | |
| (uint32_t)f16BitUnits.length() * 2, checksum); | |
| } | |
| indexes[URES_INDEX_POOL_CHECKSUM] = (int32_t)checksum; | |
| } else if (gUsePoolBundle) { | |
| indexes[URES_INDEX_ATTRIBUTES] |= URES_ATT_USES_POOL_BUNDLE; | |
| indexes[URES_INDEX_POOL_CHECKSUM] = fUsePoolBundle->fChecksum; | |
| } | |
| } | |
| // formatVersion 3 (ICU 56): | |
| // share string values via pool bundle strings | |
| indexes[URES_INDEX_LENGTH] |= fPoolStringIndexLimit << 8; // bits 23..0 -> 31..8 | |
| indexes[URES_INDEX_ATTRIBUTES] |= (fPoolStringIndexLimit >> 12) & 0xf000; // bits 27..24 -> 15..12 | |
| indexes[URES_INDEX_ATTRIBUTES] |= fPoolStringIndex16Limit << 16; | |
| /* write the indexes[] */ | |
| udata_writeBlock(mem, indexes, fIndexLength*4); | |
| /* write the table key strings */ | |
| udata_writeBlock(mem, fKeys+fKeysBottom, | |
| fKeysTop-fKeysBottom); | |
| /* write the v2 UTF-16 strings, URES_TABLE16 and URES_ARRAY16 */ | |
| udata_writeBlock(mem, f16BitUnits.getBuffer(), f16BitUnits.length()*2); | |
| /* write all of the bundle contents: the root item and its children */ | |
| byteOffset = fKeysTop + f16BitUnits.length() * 2; | |
| fRoot->write(mem, &byteOffset); | |
| assert(byteOffset == top); | |
| size = udata_finish(mem, &errorCode); | |
| if(top != size) { | |
| fprintf(stderr, "genrb error: wrote %u bytes but counted %u\n", | |
| (int)size, (int)top); | |
| errorCode = U_INTERNAL_PROGRAM_ERROR; | |
| } | |
| } | |
| /* Opening Functions */ | |
| TableResource* table_open(struct SRBRoot *bundle, const char *tag, const struct UString* comment, UErrorCode *status) { | |
| LocalPointer<TableResource> res(new TableResource(bundle, tag, comment, *status), *status); | |
| return U_SUCCESS(*status) ? res.orphan() : NULL; | |
| } | |
| ArrayResource* array_open(struct SRBRoot *bundle, const char *tag, const struct UString* comment, UErrorCode *status) { | |
| LocalPointer<ArrayResource> res(new ArrayResource(bundle, tag, comment, *status), *status); | |
| return U_SUCCESS(*status) ? res.orphan() : NULL; | |
| } | |
| struct SResource *string_open(struct SRBRoot *bundle, const char *tag, const UChar *value, int32_t len, const struct UString* comment, UErrorCode *status) { | |
| LocalPointer<SResource> res( | |
| new StringResource(bundle, tag, value, len, comment, *status), *status); | |
| return U_SUCCESS(*status) ? res.orphan() : NULL; | |
| } | |
| struct SResource *alias_open(struct SRBRoot *bundle, const char *tag, UChar *value, int32_t len, const struct UString* comment, UErrorCode *status) { | |
| LocalPointer<SResource> res( | |
| new AliasResource(bundle, tag, value, len, comment, *status), *status); | |
| return U_SUCCESS(*status) ? res.orphan() : NULL; | |
| } | |
| IntVectorResource *intvector_open(struct SRBRoot *bundle, const char *tag, const struct UString* comment, UErrorCode *status) { | |
| LocalPointer<IntVectorResource> res( | |
| new IntVectorResource(bundle, tag, comment, *status), *status); | |
| return U_SUCCESS(*status) ? res.orphan() : NULL; | |
| } | |
| struct SResource *int_open(struct SRBRoot *bundle, const char *tag, int32_t value, const struct UString* comment, UErrorCode *status) { | |
| LocalPointer<SResource> res(new IntResource(bundle, tag, value, comment, *status), *status); | |
| return U_SUCCESS(*status) ? res.orphan() : NULL; | |
| } | |
| struct SResource *bin_open(struct SRBRoot *bundle, const char *tag, uint32_t length, uint8_t *data, const char* fileName, const struct UString* comment, UErrorCode *status) { | |
| LocalPointer<SResource> res( | |
| new BinaryResource(bundle, tag, length, data, fileName, comment, *status), *status); | |
| return U_SUCCESS(*status) ? res.orphan() : NULL; | |
| } | |
| SRBRoot::SRBRoot(const UString *comment, UBool isPoolBundle, UErrorCode &errorCode) | |
| : fRoot(NULL), fLocale(NULL), fIndexLength(0), fMaxTableLength(0), fNoFallback(FALSE), | |
| fStringsForm(STRINGS_UTF16_V1), fIsPoolBundle(isPoolBundle), | |
| fKeys(NULL), fKeyMap(NULL), | |
| fKeysBottom(0), fKeysTop(0), fKeysCapacity(0), fKeysCount(0), fLocalKeyLimit(0), | |
| f16BitUnits(), f16BitStringsLength(0), | |
| fUsePoolBundle(&kNoPoolBundle), | |
| fPoolStringIndexLimit(0), fPoolStringIndex16Limit(0), fLocalStringIndexLimit(0), | |
| fWritePoolBundle(NULL) { | |
| if (U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| if (gFormatVersion > 1) { | |
| // f16BitUnits must start with a zero for empty resources. | |
| // We might be able to omit it if there are no empty 16-bit resources. | |
| f16BitUnits.append((UChar)0); | |
| } | |
| fKeys = (char *) uprv_malloc(sizeof(char) * KEY_SPACE_SIZE); | |
| if (isPoolBundle) { | |
| fRoot = new PseudoListResource(this, errorCode); | |
| } else { | |
| fRoot = new TableResource(this, NULL, comment, errorCode); | |
| } | |
| if (fKeys == NULL || fRoot == NULL || U_FAILURE(errorCode)) { | |
| if (U_SUCCESS(errorCode)) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| return; | |
| } | |
| fKeysCapacity = KEY_SPACE_SIZE; | |
| /* formatVersion 1.1 and up: start fKeysTop after the root item and indexes[] */ | |
| if (gUsePoolBundle || isPoolBundle) { | |
| fIndexLength = URES_INDEX_POOL_CHECKSUM + 1; | |
| } else if (gFormatVersion >= 2) { | |
| fIndexLength = URES_INDEX_16BIT_TOP + 1; | |
| } else /* formatVersion 1 */ { | |
| fIndexLength = URES_INDEX_ATTRIBUTES + 1; | |
| } | |
| fKeysBottom = (1 /* root */ + fIndexLength) * 4; | |
| uprv_memset(fKeys, 0, fKeysBottom); | |
| fKeysTop = fKeysBottom; | |
| if (gFormatVersion == 1) { | |
| fStringsForm = STRINGS_UTF16_V1; | |
| } else { | |
| fStringsForm = STRINGS_UTF16_V2; | |
| } | |
| } | |
| /* Closing Functions */ | |
| void res_close(struct SResource *res) { | |
| delete res; | |
| } | |
| SRBRoot::~SRBRoot() { | |
| delete fRoot; | |
| uprv_free(fLocale); | |
| uprv_free(fKeys); | |
| uprv_free(fKeyMap); | |
| } | |
| /* Misc Functions */ | |
| void SRBRoot::setLocale(UChar *locale, UErrorCode &errorCode) { | |
| if(U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| uprv_free(fLocale); | |
| fLocale = (char*) uprv_malloc(sizeof(char) * (u_strlen(locale)+1)); | |
| if(fLocale == NULL) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| u_UCharsToChars(locale, fLocale, u_strlen(locale)+1); | |
| } | |
| const char * | |
| SRBRoot::getKeyString(int32_t key) const { | |
| if (key < 0) { | |
| return fUsePoolBundle->fKeys + (key & 0x7fffffff); | |
| } else { | |
| return fKeys + key; | |
| } | |
| } | |
| const char * | |
| SResource::getKeyString(const SRBRoot *bundle) const { | |
| if (fKey == -1) { | |
| return NULL; | |
| } | |
| return bundle->getKeyString(fKey); | |
| } | |
| const char * | |
| SRBRoot::getKeyBytes(int32_t *pLength) const { | |
| *pLength = fKeysTop - fKeysBottom; | |
| return fKeys + fKeysBottom; | |
| } | |
| int32_t | |
| SRBRoot::addKeyBytes(const char *keyBytes, int32_t length, UErrorCode &errorCode) { | |
| int32_t keypos; | |
| if (U_FAILURE(errorCode)) { | |
| return -1; | |
| } | |
| if (length < 0 || (keyBytes == NULL && length != 0)) { | |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; | |
| return -1; | |
| } | |
| if (length == 0) { | |
| return fKeysTop; | |
| } | |
| keypos = fKeysTop; | |
| fKeysTop += length; | |
| if (fKeysTop >= fKeysCapacity) { | |
| /* overflow - resize the keys buffer */ | |
| fKeysCapacity += KEY_SPACE_SIZE; | |
| fKeys = static_cast<char *>(uprv_realloc(fKeys, fKeysCapacity)); | |
| if(fKeys == NULL) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| return -1; | |
| } | |
| } | |
| uprv_memcpy(fKeys + keypos, keyBytes, length); | |
| return keypos; | |
| } | |
| int32_t | |
| SRBRoot::addTag(const char *tag, UErrorCode &errorCode) { | |
| int32_t keypos; | |
| if (U_FAILURE(errorCode)) { | |
| return -1; | |
| } | |
| if (tag == NULL) { | |
| /* no error: the root table and array items have no keys */ | |
| return -1; | |
| } | |
| keypos = addKeyBytes(tag, (int32_t)(uprv_strlen(tag) + 1), errorCode); | |
| if (U_SUCCESS(errorCode)) { | |
| ++fKeysCount; | |
| } | |
| return keypos; | |
| } | |
| static int32_t | |
| compareInt32(int32_t lPos, int32_t rPos) { | |
| /* | |
| * Compare possibly-negative key offsets. Don't just return lPos - rPos | |
| * because that is prone to negative-integer underflows. | |
| */ | |
| if (lPos < rPos) { | |
| return -1; | |
| } else if (lPos > rPos) { | |
| return 1; | |
| } else { | |
| return 0; | |
| } | |
| } | |
| static int32_t U_CALLCONV | |
| compareKeySuffixes(const void *context, const void *l, const void *r) { | |
| const struct SRBRoot *bundle=(const struct SRBRoot *)context; | |
| int32_t lPos = ((const KeyMapEntry *)l)->oldpos; | |
| int32_t rPos = ((const KeyMapEntry *)r)->oldpos; | |
| const char *lStart = bundle->getKeyString(lPos); | |
| const char *lLimit = lStart; | |
| const char *rStart = bundle->getKeyString(rPos); | |
| const char *rLimit = rStart; | |
| int32_t diff; | |
| while (*lLimit != 0) { ++lLimit; } | |
| while (*rLimit != 0) { ++rLimit; } | |
| /* compare keys in reverse character order */ | |
| while (lStart < lLimit && rStart < rLimit) { | |
| diff = (int32_t)(uint8_t)*--lLimit - (int32_t)(uint8_t)*--rLimit; | |
| if (diff != 0) { | |
| return diff; | |
| } | |
| } | |
| /* sort equal suffixes by descending key length */ | |
| diff = (int32_t)(rLimit - rStart) - (int32_t)(lLimit - lStart); | |
| if (diff != 0) { | |
| return diff; | |
| } | |
| /* Sort pool bundle keys first (negative oldpos), and otherwise keys in parsing order. */ | |
| return compareInt32(lPos, rPos); | |
| } | |
| static int32_t U_CALLCONV | |
| compareKeyNewpos(const void * /*context*/, const void *l, const void *r) { | |
| return compareInt32(((const KeyMapEntry *)l)->newpos, ((const KeyMapEntry *)r)->newpos); | |
| } | |
| static int32_t U_CALLCONV | |
| compareKeyOldpos(const void * /*context*/, const void *l, const void *r) { | |
| return compareInt32(((const KeyMapEntry *)l)->oldpos, ((const KeyMapEntry *)r)->oldpos); | |
| } | |
| void | |
| SRBRoot::compactKeys(UErrorCode &errorCode) { | |
| KeyMapEntry *map; | |
| char *keys; | |
| int32_t i; | |
| int32_t keysCount = fUsePoolBundle->fKeysCount + fKeysCount; | |
| if (U_FAILURE(errorCode) || fKeysCount == 0 || fKeyMap != NULL) { | |
| return; | |
| } | |
| map = (KeyMapEntry *)uprv_malloc(keysCount * sizeof(KeyMapEntry)); | |
| if (map == NULL) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| keys = (char *)fUsePoolBundle->fKeys; | |
| for (i = 0; i < fUsePoolBundle->fKeysCount; ++i) { | |
| map[i].oldpos = | |
| (int32_t)(keys - fUsePoolBundle->fKeys) | 0x80000000; /* negative oldpos */ | |
| map[i].newpos = 0; | |
| while (*keys != 0) { ++keys; } /* skip the key */ | |
| ++keys; /* skip the NUL */ | |
| } | |
| keys = fKeys + fKeysBottom; | |
| for (; i < keysCount; ++i) { | |
| map[i].oldpos = (int32_t)(keys - fKeys); | |
| map[i].newpos = 0; | |
| while (*keys != 0) { ++keys; } /* skip the key */ | |
| ++keys; /* skip the NUL */ | |
| } | |
| /* Sort the keys so that each one is immediately followed by all of its suffixes. */ | |
| uprv_sortArray(map, keysCount, (int32_t)sizeof(KeyMapEntry), | |
| compareKeySuffixes, this, FALSE, &errorCode); | |
| /* | |
| * Make suffixes point into earlier, longer strings that contain them | |
| * and mark the old, now unused suffix bytes as deleted. | |
| */ | |
| if (U_SUCCESS(errorCode)) { | |
| keys = fKeys; | |
| for (i = 0; i < keysCount;) { | |
| /* | |
| * This key is not a suffix of the previous one; | |
| * keep this one and delete the following ones that are | |
| * suffixes of this one. | |
| */ | |
| const char *key; | |
| const char *keyLimit; | |
| int32_t j = i + 1; | |
| map[i].newpos = map[i].oldpos; | |
| if (j < keysCount && map[j].oldpos < 0) { | |
| /* Key string from the pool bundle, do not delete. */ | |
| i = j; | |
| continue; | |
| } | |
| key = getKeyString(map[i].oldpos); | |
| for (keyLimit = key; *keyLimit != 0; ++keyLimit) {} | |
| for (; j < keysCount && map[j].oldpos >= 0; ++j) { | |
| const char *k; | |
| char *suffix; | |
| const char *suffixLimit; | |
| int32_t offset; | |
| suffix = keys + map[j].oldpos; | |
| for (suffixLimit = suffix; *suffixLimit != 0; ++suffixLimit) {} | |
| offset = (int32_t)(keyLimit - key) - (suffixLimit - suffix); | |
| if (offset < 0) { | |
| break; /* suffix cannot be longer than the original */ | |
| } | |
| /* Is it a suffix of the earlier, longer key? */ | |
| for (k = keyLimit; suffix < suffixLimit && *--k == *--suffixLimit;) {} | |
| if (suffix == suffixLimit && *k == *suffixLimit) { | |
| map[j].newpos = map[i].oldpos + offset; /* yes, point to the earlier key */ | |
| /* mark the suffix as deleted */ | |
| while (*suffix != 0) { *suffix++ = 1; } | |
| *suffix = 1; | |
| } else { | |
| break; /* not a suffix, restart from here */ | |
| } | |
| } | |
| i = j; | |
| } | |
| /* | |
| * Re-sort by newpos, then modify the key characters array in-place | |
| * to squeeze out unused bytes, and readjust the newpos offsets. | |
| */ | |
| uprv_sortArray(map, keysCount, (int32_t)sizeof(KeyMapEntry), | |
| compareKeyNewpos, NULL, FALSE, &errorCode); | |
| if (U_SUCCESS(errorCode)) { | |
| int32_t oldpos, newpos, limit; | |
| oldpos = newpos = fKeysBottom; | |
| limit = fKeysTop; | |
| /* skip key offsets that point into the pool bundle rather than this new bundle */ | |
| for (i = 0; i < keysCount && map[i].newpos < 0; ++i) {} | |
| if (i < keysCount) { | |
| while (oldpos < limit) { | |
| if (keys[oldpos] == 1) { | |
| ++oldpos; /* skip unused bytes */ | |
| } else { | |
| /* adjust the new offsets for keys starting here */ | |
| while (i < keysCount && map[i].newpos == oldpos) { | |
| map[i++].newpos = newpos; | |
| } | |
| /* move the key characters to their new position */ | |
| keys[newpos++] = keys[oldpos++]; | |
| } | |
| } | |
| assert(i == keysCount); | |
| } | |
| fKeysTop = newpos; | |
| /* Re-sort once more, by old offsets for binary searching. */ | |
| uprv_sortArray(map, keysCount, (int32_t)sizeof(KeyMapEntry), | |
| compareKeyOldpos, NULL, FALSE, &errorCode); | |
| if (U_SUCCESS(errorCode)) { | |
| /* key size reduction by limit - newpos */ | |
| fKeyMap = map; | |
| map = NULL; | |
| } | |
| } | |
| } | |
| uprv_free(map); | |
| } | |
| static int32_t U_CALLCONV | |
| compareStringSuffixes(const void * /*context*/, const void *l, const void *r) { | |
| const StringResource *left = *((const StringResource **)l); | |
| const StringResource *right = *((const StringResource **)r); | |
| const UChar *lStart = left->getBuffer(); | |
| const UChar *lLimit = lStart + left->length(); | |
| const UChar *rStart = right->getBuffer(); | |
| const UChar *rLimit = rStart + right->length(); | |
| int32_t diff; | |
| /* compare keys in reverse character order */ | |
| while (lStart < lLimit && rStart < rLimit) { | |
| diff = (int32_t)*--lLimit - (int32_t)*--rLimit; | |
| if (diff != 0) { | |
| return diff; | |
| } | |
| } | |
| /* sort equal suffixes by descending string length */ | |
| return right->length() - left->length(); | |
| } | |
| static int32_t U_CALLCONV | |
| compareStringLengths(const void * /*context*/, const void *l, const void *r) { | |
| const StringResource *left = *((const StringResource **)l); | |
| const StringResource *right = *((const StringResource **)r); | |
| int32_t diff; | |
| /* Make "is suffix of another string" compare greater than a non-suffix. */ | |
| diff = (int)(left->fSame != NULL) - (int)(right->fSame != NULL); | |
| if (diff != 0) { | |
| return diff; | |
| } | |
| /* sort by ascending string length */ | |
| diff = left->length() - right->length(); | |
| if (diff != 0) { | |
| return diff; | |
| } | |
| // sort by descending size reduction | |
| diff = right->fNumUnitsSaved - left->fNumUnitsSaved; | |
| if (diff != 0) { | |
| return diff; | |
| } | |
| // sort lexically | |
| return left->fString.compare(right->fString); | |
| } | |
| void | |
| StringResource::writeUTF16v2(int32_t base, UnicodeString &dest) { | |
| int32_t len = length(); | |
| fRes = URES_MAKE_RESOURCE(URES_STRING_V2, base + dest.length()); | |
| fWritten = TRUE; | |
| switch(fNumCharsForLength) { | |
| case 0: | |
| break; | |
| case 1: | |
| dest.append((UChar)(0xdc00 + len)); | |
| break; | |
| case 2: | |
| dest.append((UChar)(0xdfef + (len >> 16))); | |
| dest.append((UChar)len); | |
| break; | |
| case 3: | |
| dest.append((UChar)0xdfff); | |
| dest.append((UChar)(len >> 16)); | |
| dest.append((UChar)len); | |
| break; | |
| default: | |
| break; /* will not occur */ | |
| } | |
| dest.append(fString); | |
| dest.append((UChar)0); | |
| } | |
| void | |
| SRBRoot::compactStringsV2(UHashtable *stringSet, UErrorCode &errorCode) { | |
| if (U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| // Store the StringResource pointers in an array for | |
| // easy sorting and processing. | |
| // We enumerate a set of strings, so there are no duplicates. | |
| int32_t count = uhash_count(stringSet); | |
| LocalArray<StringResource *> array(new StringResource *[count], errorCode); | |
| if (U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| for (int32_t pos = UHASH_FIRST, i = 0; i < count; ++i) { | |
| array[i] = (StringResource *)uhash_nextElement(stringSet, &pos)->key.pointer; | |
| } | |
| /* Sort the strings so that each one is immediately followed by all of its suffixes. */ | |
| uprv_sortArray(array.getAlias(), count, (int32_t)sizeof(struct SResource **), | |
| compareStringSuffixes, NULL, FALSE, &errorCode); | |
| if (U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| /* | |
| * Make suffixes point into earlier, longer strings that contain them. | |
| * Temporarily use fSame and fSuffixOffset for suffix strings to | |
| * refer to the remaining ones. | |
| */ | |
| for (int32_t i = 0; i < count;) { | |
| /* | |
| * This string is not a suffix of the previous one; | |
| * write this one and subsume the following ones that are | |
| * suffixes of this one. | |
| */ | |
| StringResource *res = array[i]; | |
| res->fNumUnitsSaved = (res->fNumCopies - 1) * res->get16BitStringsLength(); | |
| // Whole duplicates of pool strings are already account for in fPoolStringIndexLimit, | |
| // see StringResource::handlePreflightStrings(). | |
| int32_t j; | |
| for (j = i + 1; j < count; ++j) { | |
| StringResource *suffixRes = array[j]; | |
| /* Is it a suffix of the earlier, longer string? */ | |
| if (res->fString.endsWith(suffixRes->fString)) { | |
| assert(res->length() != suffixRes->length()); // Set strings are unique. | |
| if (suffixRes->fWritten) { | |
| // Pool string, skip. | |
| } else if (suffixRes->fNumCharsForLength == 0) { | |
| /* yes, point to the earlier string */ | |
| suffixRes->fSame = res; | |
| suffixRes->fSuffixOffset = res->length() - suffixRes->length(); | |
| if (res->fWritten) { | |
| // Suffix-share res which is a pool string. | |
| // Compute the resource word and collect the maximum. | |
| suffixRes->fRes = | |
| res->fRes + res->fNumCharsForLength + suffixRes->fSuffixOffset; | |
| int32_t poolStringIndex = (int32_t)RES_GET_OFFSET(suffixRes->fRes); | |
| if (poolStringIndex >= fPoolStringIndexLimit) { | |
| fPoolStringIndexLimit = poolStringIndex + 1; | |
| } | |
| suffixRes->fWritten = TRUE; | |
| } | |
| res->fNumUnitsSaved += suffixRes->fNumCopies * suffixRes->get16BitStringsLength(); | |
| } else { | |
| /* write the suffix by itself if we need explicit length */ | |
| } | |
| } else { | |
| break; /* not a suffix, restart from here */ | |
| } | |
| } | |
| i = j; | |
| } | |
| /* | |
| * Re-sort the strings by ascending length (except suffixes last) | |
| * to optimize for URES_TABLE16 and URES_ARRAY16: | |
| * Keep as many as possible within reach of 16-bit offsets. | |
| */ | |
| uprv_sortArray(array.getAlias(), count, (int32_t)sizeof(struct SResource **), | |
| compareStringLengths, NULL, FALSE, &errorCode); | |
| if (U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| if (fIsPoolBundle) { | |
| // Write strings that are sufficiently shared. | |
| // Avoid writing other strings. | |
| int32_t numStringsWritten = 0; | |
| int32_t numUnitsSaved = 0; | |
| int32_t numUnitsNotSaved = 0; | |
| for (int32_t i = 0; i < count; ++i) { | |
| StringResource *res = array[i]; | |
| // Maximum pool string index when suffix-sharing the last character. | |
| int32_t maxStringIndex = | |
| f16BitUnits.length() + res->fNumCharsForLength + res->length() - 1; | |
| if (res->fNumUnitsSaved >= GENRB_MIN_16BIT_UNITS_SAVED_FOR_POOL_STRING && | |
| maxStringIndex < RES_MAX_OFFSET) { | |
| res->writeUTF16v2(0, f16BitUnits); | |
| ++numStringsWritten; | |
| numUnitsSaved += res->fNumUnitsSaved; | |
| } else { | |
| numUnitsNotSaved += res->fNumUnitsSaved; | |
| res->fRes = URES_MAKE_EMPTY_RESOURCE(URES_STRING); | |
| res->fWritten = TRUE; | |
| } | |
| } | |
| if (f16BitUnits.isBogus()) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| if (getShowWarning()) { // not quiet | |
| printf("number of shared strings: %d\n", (int)numStringsWritten); | |
| printf("16-bit units for strings: %6d = %6d bytes\n", | |
| (int)f16BitUnits.length(), (int)f16BitUnits.length() * 2); | |
| printf("16-bit units saved: %6d = %6d bytes\n", | |
| (int)numUnitsSaved, (int)numUnitsSaved * 2); | |
| printf("16-bit units not saved: %6d = %6d bytes\n", | |
| (int)numUnitsNotSaved, (int)numUnitsNotSaved * 2); | |
| } | |
| } else { | |
| assert(fPoolStringIndexLimit <= fUsePoolBundle->fStringIndexLimit); | |
| /* Write the non-suffix strings. */ | |
| int32_t i; | |
| for (i = 0; i < count && array[i]->fSame == NULL; ++i) { | |
| StringResource *res = array[i]; | |
| if (!res->fWritten) { | |
| int32_t localStringIndex = f16BitUnits.length(); | |
| if (localStringIndex >= fLocalStringIndexLimit) { | |
| fLocalStringIndexLimit = localStringIndex + 1; | |
| } | |
| res->writeUTF16v2(fPoolStringIndexLimit, f16BitUnits); | |
| } | |
| } | |
| if (f16BitUnits.isBogus()) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| if (fWritePoolBundle != NULL && gFormatVersion >= 3) { | |
| PseudoListResource *poolStrings = | |
| static_cast<PseudoListResource *>(fWritePoolBundle->fRoot); | |
| for (i = 0; i < count && array[i]->fSame == NULL; ++i) { | |
| assert(!array[i]->fString.isEmpty()); | |
| StringResource *poolString = | |
| new StringResource(fWritePoolBundle, array[i]->fString, errorCode); | |
| if (poolString == NULL) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| break; | |
| } | |
| poolStrings->add(poolString); | |
| } | |
| } | |
| /* Write the suffix strings. Make each point to the real string. */ | |
| for (; i < count; ++i) { | |
| StringResource *res = array[i]; | |
| if (res->fWritten) { | |
| continue; | |
| } | |
| StringResource *same = res->fSame; | |
| assert(res->length() != same->length()); // Set strings are unique. | |
| res->fRes = same->fRes + same->fNumCharsForLength + res->fSuffixOffset; | |
| int32_t localStringIndex = (int32_t)RES_GET_OFFSET(res->fRes) - fPoolStringIndexLimit; | |
| // Suffixes of pool strings have been set already. | |
| assert(localStringIndex >= 0); | |
| if (localStringIndex >= fLocalStringIndexLimit) { | |
| fLocalStringIndexLimit = localStringIndex + 1; | |
| } | |
| res->fWritten = TRUE; | |
| } | |
| } | |
| // +1 to account for the initial zero in f16BitUnits | |
| assert(f16BitUnits.length() <= (f16BitStringsLength + 1)); | |
| } |