ICU 56 update step 1

source/i18n/collationdatawriter.cpp

 /*
 *******************************************************************************
-* Copyright (C) 2013-2014, International Business Machines
+* 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"
 
@@ skipping 47 matching lines @@
 static const UDataInfo dataInfo = {
     sizeof(UDataInfo),
     0,
 
     U_IS_BIG_ENDIAN,
     U_CHARSET_FAMILY,
     U_SIZEOF_UCHAR,
     0,
 
     { 0x55, 0x43, 0x6f, 0x6c },         // dataFormat="UCol"
-    { 4, 0, 0, 0 },                     // formatVersion
+    { 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,
@@ skipping 68 matching lines @@
         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 + settings.reorderCodesLength) * 4;
+            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) {
@@ skipping 19 matching lines @@
     // 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] = data.jamoCE32s - data.ce32s;
     } else {
         indexes[CollationDataReader::IX_JAMO_CE32S_START] = -1;
     }
 
     indexes[CollationDataReader::IX_REORDER_CODES_OFFSET] = totalSize;
-    totalSize += settings.reorderCodesLength * 4;
+    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;
@@ skipping 48 matching lines @@
         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) {
-        totalSize += data.scriptsLength * 2;
+        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, settings.reorderCodes, dest);
+    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, data.scripts, 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