summaryrefslogtreecommitdiff
path: root/deps/node/deps/icu-small/source/i18n/collationdatawriter.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'deps/node/deps/icu-small/source/i18n/collationdatawriter.cpp')
-rw-r--r--deps/node/deps/icu-small/source/i18n/collationdatawriter.cpp352
1 files changed, 0 insertions, 352 deletions
diff --git a/deps/node/deps/icu-small/source/i18n/collationdatawriter.cpp b/deps/node/deps/icu-small/source/i18n/collationdatawriter.cpp
deleted file mode 100644
index 823c8eb0..00000000
--- a/deps/node/deps/icu-small/source/i18n/collationdatawriter.cpp
+++ /dev/null
@@ -1,352 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2013-2015, International Business Machines
-* Corporation and others. All Rights Reserved.
-*******************************************************************************
-* collationdatawriter.cpp
-*
-* created on: 2013aug06
-* created by: Markus W. Scherer
-*/
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_COLLATION
-
-#include "unicode/tblcoll.h"
-#include "unicode/udata.h"
-#include "unicode/uniset.h"
-#include "cmemory.h"
-#include "collationdata.h"
-#include "collationdatabuilder.h"
-#include "collationdatareader.h"
-#include "collationdatawriter.h"
-#include "collationfastlatin.h"
-#include "collationsettings.h"
-#include "collationtailoring.h"
-#include "uassert.h"
-#include "ucmndata.h"
-
-U_NAMESPACE_BEGIN
-
-uint8_t *
-RuleBasedCollator::cloneRuleData(int32_t &length, UErrorCode &errorCode) const {
- if(U_FAILURE(errorCode)) { return NULL; }
- LocalMemory<uint8_t> buffer((uint8_t *)uprv_malloc(20000));
- if(buffer.isNull()) {
- errorCode = U_MEMORY_ALLOCATION_ERROR;
- return NULL;
- }
- length = cloneBinary(buffer.getAlias(), 20000, errorCode);
- if(errorCode == U_BUFFER_OVERFLOW_ERROR) {
- if(buffer.allocateInsteadAndCopy(length, 0) == NULL) {
- errorCode = U_MEMORY_ALLOCATION_ERROR;
- return NULL;
- }
- errorCode = U_ZERO_ERROR;
- length = cloneBinary(buffer.getAlias(), length, errorCode);
- }
- if(U_FAILURE(errorCode)) { return NULL; }
- return buffer.orphan();
-}
-
-int32_t
-RuleBasedCollator::cloneBinary(uint8_t *dest, int32_t capacity, UErrorCode &errorCode) const {
- int32_t indexes[CollationDataReader::IX_TOTAL_SIZE + 1];
- return CollationDataWriter::writeTailoring(
- *tailoring, *settings, indexes, dest, capacity,
- errorCode);
-}
-
-static const UDataInfo dataInfo = {
- sizeof(UDataInfo),
- 0,
-
- U_IS_BIG_ENDIAN,
- U_CHARSET_FAMILY,
- U_SIZEOF_UCHAR,
- 0,
-
- { 0x55, 0x43, 0x6f, 0x6c }, // dataFormat="UCol"
- { 5, 0, 0, 0 }, // formatVersion
- { 6, 3, 0, 0 } // dataVersion
-};
-
-int32_t
-CollationDataWriter::writeBase(const CollationData &data, const CollationSettings &settings,
- const void *rootElements, int32_t rootElementsLength,
- int32_t indexes[], uint8_t *dest, int32_t capacity,
- UErrorCode &errorCode) {
- return write(TRUE, NULL,
- data, settings,
- rootElements, rootElementsLength,
- indexes, dest, capacity, errorCode);
-}
-
-int32_t
-CollationDataWriter::writeTailoring(const CollationTailoring &t, const CollationSettings &settings,
- int32_t indexes[], uint8_t *dest, int32_t capacity,
- UErrorCode &errorCode) {
- return write(FALSE, t.version,
- *t.data, settings,
- NULL, 0,
- indexes, dest, capacity, errorCode);
-}
-
-int32_t
-CollationDataWriter::write(UBool isBase, const UVersionInfo dataVersion,
- const CollationData &data, const CollationSettings &settings,
- const void *rootElements, int32_t rootElementsLength,
- int32_t indexes[], uint8_t *dest, int32_t capacity,
- UErrorCode &errorCode) {
- if(U_FAILURE(errorCode)) { return 0; }
- if(capacity < 0 || (capacity > 0 && dest == NULL)) {
- errorCode = U_ILLEGAL_ARGUMENT_ERROR;
- return 0;
- }
-
- // Figure out which data items to write before settling on
- // the indexes length and writing offsets.
- // For any data item, we need to write the start and limit offsets,
- // so the indexes length must be at least index-of-start-offset + 2.
- int32_t indexesLength;
- UBool hasMappings;
- UnicodeSet unsafeBackwardSet;
- const CollationData *baseData = data.base;
-
- int32_t fastLatinVersion;
- if(data.fastLatinTable != NULL) {
- fastLatinVersion = (int32_t)CollationFastLatin::VERSION << 16;
- } else {
- fastLatinVersion = 0;
- }
- int32_t fastLatinTableLength = 0;
-
- if(isBase) {
- // For the root collator, we write an even number of indexes
- // so that we start with an 8-aligned offset.
- indexesLength = CollationDataReader::IX_TOTAL_SIZE + 1;
- U_ASSERT(settings.reorderCodesLength == 0);
- hasMappings = TRUE;
- unsafeBackwardSet = *data.unsafeBackwardSet;
- fastLatinTableLength = data.fastLatinTableLength;
- } else if(baseData == NULL) {
- hasMappings = FALSE;
- if(settings.reorderCodesLength == 0) {
- // only options
- indexesLength = CollationDataReader::IX_OPTIONS + 1; // no limit offset here
- } else {
- // only options, reorder codes, and the reorder table
- indexesLength = CollationDataReader::IX_REORDER_TABLE_OFFSET + 2;
- }
- } else {
- hasMappings = TRUE;
- // Tailored mappings, and what else?
- // Check in ascending order of optional tailoring data items.
- indexesLength = CollationDataReader::IX_CE32S_OFFSET + 2;
- if(data.contextsLength != 0) {
- indexesLength = CollationDataReader::IX_CONTEXTS_OFFSET + 2;
- }
- unsafeBackwardSet.addAll(*data.unsafeBackwardSet).removeAll(*baseData->unsafeBackwardSet);
- if(!unsafeBackwardSet.isEmpty()) {
- indexesLength = CollationDataReader::IX_UNSAFE_BWD_OFFSET + 2;
- }
- if(data.fastLatinTable != baseData->fastLatinTable) {
- fastLatinTableLength = data.fastLatinTableLength;
- indexesLength = CollationDataReader::IX_FAST_LATIN_TABLE_OFFSET + 2;
- }
- }
-
- UVector32 codesAndRanges(errorCode);
- const int32_t *reorderCodes = settings.reorderCodes;
- int32_t reorderCodesLength = settings.reorderCodesLength;
- if(settings.hasReordering() &&
- CollationSettings::reorderTableHasSplitBytes(settings.reorderTable)) {
- // Rebuild the full list of reorder ranges.
- // The list in the settings is truncated for efficiency.
- data.makeReorderRanges(reorderCodes, reorderCodesLength, codesAndRanges, errorCode);
- // Write the codes, then the ranges.
- for(int32_t i = 0; i < reorderCodesLength; ++i) {
- codesAndRanges.insertElementAt(reorderCodes[i], i, errorCode);
- }
- if(U_FAILURE(errorCode)) { return 0; }
- reorderCodes = codesAndRanges.getBuffer();
- reorderCodesLength = codesAndRanges.size();
- }
-
- int32_t headerSize;
- if(isBase) {
- headerSize = 0; // udata_create() writes the header
- } else {
- DataHeader header;
- header.dataHeader.magic1 = 0xda;
- header.dataHeader.magic2 = 0x27;
- uprv_memcpy(&header.info, &dataInfo, sizeof(UDataInfo));
- uprv_memcpy(header.info.dataVersion, dataVersion, sizeof(UVersionInfo));
- headerSize = (int32_t)sizeof(header);
- U_ASSERT((headerSize & 3) == 0); // multiple of 4 bytes
- if(hasMappings && data.cesLength != 0) {
- // Sum of the sizes of the data items which are
- // not automatically multiples of 8 bytes and which are placed before the CEs.
- int32_t sum = headerSize + (indexesLength + reorderCodesLength) * 4;
- if((sum & 7) != 0) {
- // We need to add padding somewhere so that the 64-bit CEs are 8-aligned.
- // We add to the header size here.
- // Alternatively, we could increment the indexesLength
- // or add a few bytes to the reorderTable.
- headerSize += 4;
- }
- }
- header.dataHeader.headerSize = (uint16_t)headerSize;
- if(headerSize <= capacity) {
- uprv_memcpy(dest, &header, sizeof(header));
- // Write 00 bytes so that the padding is not mistaken for a copyright string.
- uprv_memset(dest + sizeof(header), 0, headerSize - (int32_t)sizeof(header));
- dest += headerSize;
- capacity -= headerSize;
- } else {
- dest = NULL;
- capacity = 0;
- }
- }
-
- indexes[CollationDataReader::IX_INDEXES_LENGTH] = indexesLength;
- U_ASSERT((settings.options & ~0xffff) == 0);
- indexes[CollationDataReader::IX_OPTIONS] =
- data.numericPrimary | fastLatinVersion | settings.options;
- indexes[CollationDataReader::IX_RESERVED2] = 0;
- indexes[CollationDataReader::IX_RESERVED3] = 0;
-
- // Byte offsets of data items all start from the start of the indexes.
- // We add the headerSize at the very end.
- int32_t totalSize = indexesLength * 4;
-
- if(hasMappings && (isBase || data.jamoCE32s != baseData->jamoCE32s)) {
- indexes[CollationDataReader::IX_JAMO_CE32S_START] = static_cast<int32_t>(data.jamoCE32s - data.ce32s);
- } else {
- indexes[CollationDataReader::IX_JAMO_CE32S_START] = -1;
- }
-
- indexes[CollationDataReader::IX_REORDER_CODES_OFFSET] = totalSize;
- totalSize += reorderCodesLength * 4;
-
- indexes[CollationDataReader::IX_REORDER_TABLE_OFFSET] = totalSize;
- if(settings.reorderTable != NULL) {
- totalSize += 256;
- }
-
- indexes[CollationDataReader::IX_TRIE_OFFSET] = totalSize;
- if(hasMappings) {
- UErrorCode errorCode2 = U_ZERO_ERROR;
- int32_t length;
- if(totalSize < capacity) {
- length = utrie2_serialize(data.trie, dest + totalSize,
- capacity - totalSize, &errorCode2);
- } else {
- length = utrie2_serialize(data.trie, NULL, 0, &errorCode2);
- }
- if(U_FAILURE(errorCode2) && errorCode2 != U_BUFFER_OVERFLOW_ERROR) {
- errorCode = errorCode2;
- return 0;
- }
- // The trie size should be a multiple of 8 bytes due to the way
- // compactIndex2(UNewTrie2 *trie) currently works.
- U_ASSERT((length & 7) == 0);
- totalSize += length;
- }
-
- indexes[CollationDataReader::IX_RESERVED8_OFFSET] = totalSize;
- indexes[CollationDataReader::IX_CES_OFFSET] = totalSize;
- if(hasMappings && data.cesLength != 0) {
- U_ASSERT(((headerSize + totalSize) & 7) == 0);
- totalSize += data.cesLength * 8;
- }
-
- indexes[CollationDataReader::IX_RESERVED10_OFFSET] = totalSize;
- indexes[CollationDataReader::IX_CE32S_OFFSET] = totalSize;
- if(hasMappings) {
- totalSize += data.ce32sLength * 4;
- }
-
- indexes[CollationDataReader::IX_ROOT_ELEMENTS_OFFSET] = totalSize;
- totalSize += rootElementsLength * 4;
-
- indexes[CollationDataReader::IX_CONTEXTS_OFFSET] = totalSize;
- if(hasMappings) {
- totalSize += data.contextsLength * 2;
- }
-
- indexes[CollationDataReader::IX_UNSAFE_BWD_OFFSET] = totalSize;
- if(hasMappings && !unsafeBackwardSet.isEmpty()) {
- UErrorCode errorCode2 = U_ZERO_ERROR;
- int32_t length;
- if(totalSize < capacity) {
- uint16_t *p = reinterpret_cast<uint16_t *>(dest + totalSize);
- length = unsafeBackwardSet.serialize(
- p, (capacity - totalSize) / 2, errorCode2);
- } else {
- length = unsafeBackwardSet.serialize(NULL, 0, errorCode2);
- }
- if(U_FAILURE(errorCode2) && errorCode2 != U_BUFFER_OVERFLOW_ERROR) {
- errorCode = errorCode2;
- return 0;
- }
- totalSize += length * 2;
- }
-
- indexes[CollationDataReader::IX_FAST_LATIN_TABLE_OFFSET] = totalSize;
- totalSize += fastLatinTableLength * 2;
-
- UnicodeString scripts;
- indexes[CollationDataReader::IX_SCRIPTS_OFFSET] = totalSize;
- if(isBase) {
- scripts.append((UChar)data.numScripts);
- scripts.append(reinterpret_cast<const UChar *>(data.scriptsIndex), data.numScripts + 16);
- scripts.append(reinterpret_cast<const UChar *>(data.scriptStarts), data.scriptStartsLength);
- totalSize += scripts.length() * 2;
- }
-
- indexes[CollationDataReader::IX_COMPRESSIBLE_BYTES_OFFSET] = totalSize;
- if(isBase) {
- totalSize += 256;
- }
-
- indexes[CollationDataReader::IX_RESERVED18_OFFSET] = totalSize;
- indexes[CollationDataReader::IX_TOTAL_SIZE] = totalSize;
-
- if(totalSize > capacity) {
- errorCode = U_BUFFER_OVERFLOW_ERROR;
- return headerSize + totalSize;
- }
-
- uprv_memcpy(dest, indexes, indexesLength * 4);
- copyData(indexes, CollationDataReader::IX_REORDER_CODES_OFFSET, reorderCodes, dest);
- copyData(indexes, CollationDataReader::IX_REORDER_TABLE_OFFSET, settings.reorderTable, dest);
- // The trie has already been serialized into the dest buffer.
- copyData(indexes, CollationDataReader::IX_CES_OFFSET, data.ces, dest);
- copyData(indexes, CollationDataReader::IX_CE32S_OFFSET, data.ce32s, dest);
- copyData(indexes, CollationDataReader::IX_ROOT_ELEMENTS_OFFSET, rootElements, dest);
- copyData(indexes, CollationDataReader::IX_CONTEXTS_OFFSET, data.contexts, dest);
- // The unsafeBackwardSet has already been serialized into the dest buffer.
- copyData(indexes, CollationDataReader::IX_FAST_LATIN_TABLE_OFFSET, data.fastLatinTable, dest);
- copyData(indexes, CollationDataReader::IX_SCRIPTS_OFFSET, scripts.getBuffer(), dest);
- copyData(indexes, CollationDataReader::IX_COMPRESSIBLE_BYTES_OFFSET, data.compressibleBytes, dest);
-
- return headerSize + totalSize;
-}
-
-void
-CollationDataWriter::copyData(const int32_t indexes[], int32_t startIndex,
- const void *src, uint8_t *dest) {
- int32_t start = indexes[startIndex];
- int32_t limit = indexes[startIndex + 1];
- if(start < limit) {
- uprv_memcpy(dest + start, src, limit - start);
- }
-}
-
-U_NAMESPACE_END
-
-#endif // !UCONFIG_NO_COLLATION