third_party/icu/source/common/ucol_swp.cpp - cobalt - Git at Google

 // © 2016 and later: Unicode, Inc. and others.
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 *******************************************************************************
 *
 *   Copyright (C) 2003-2015, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 *   file name:  ucol_swp.cpp
 *   encoding:   UTF-8
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 2003sep10
 *   created by: Markus W. Scherer
 *
 *   Swap collation binaries.
 */

 #if defined(STARBOARD)
 #include "starboard/client_porting/poem/string_poem.h"
 #endif  // defined(STARBOARD)
 #include "unicode/udata.h" /* UDataInfo */
 #include "utrie.h"
 #include "utrie2.h"
 #include "udataswp.h"
 #include "cmemory.h"
 #include "ucol_data.h"
 #include "ucol_swp.h"

 /* swapping ----------------------------------------------------------------- */

 #if !UCONFIG_NO_COLLATION

 U_CAPI UBool U_EXPORT2
 ucol_looksLikeCollationBinary(const UDataSwapper *ds,
                               const void *inData, int32_t length) {
     if(ds==NULL || inData==NULL || length<-1) {
         return FALSE;
     }

     // First check for format version 4+ which has a standard data header.
     UErrorCode errorCode=U_ZERO_ERROR;
     (void)udata_swapDataHeader(ds, inData, -1, NULL, &errorCode);
     if(U_SUCCESS(errorCode)) {
         const UDataInfo &info=*(const UDataInfo *)((const char *)inData+4);
         if(info.dataFormat[0]==0x55 &&   // dataFormat="UCol"
                 info.dataFormat[1]==0x43 &&
                 info.dataFormat[2]==0x6f &&
                 info.dataFormat[3]==0x6c) {
             return TRUE;
         }
     }

     // Else check for format version 3.
     const UCATableHeader *inHeader=(const UCATableHeader *)inData;

     /*
      * The collation binary must contain at least the UCATableHeader,
      * starting with its size field.
      * sizeof(UCATableHeader)==42*4 in ICU 2.8
      * check the length against the header size before reading the size field
      */
     UCATableHeader header;
     uprv_memset(&header, 0, sizeof(header));
     if(length<0) {
         header.size=udata_readInt32(ds, inHeader->size);
     } else if((length<(42*4) || length<(header.size=udata_readInt32(ds, inHeader->size)))) {
         return FALSE;
     }

     header.magic=ds->readUInt32(inHeader->magic);
     if(!(
         header.magic==UCOL_HEADER_MAGIC &&
         inHeader->formatVersion[0]==3 /*&&
         inHeader->formatVersion[1]>=0*/
     )) {
         return FALSE;
     }

     if(inHeader->isBigEndian!=ds->inIsBigEndian || inHeader->charSetFamily!=ds->inCharset) {
         return FALSE;
     }

     return TRUE;
 }

 namespace {

 /* swap a header-less collation formatVersion=3 binary, inside a resource bundle or ucadata.icu */
 int32_t
 swapFormatVersion3(const UDataSwapper *ds,
                    const void *inData, int32_t length, void *outData,
                    UErrorCode *pErrorCode) {
     const uint8_t *inBytes;
     uint8_t *outBytes;

     const UCATableHeader *inHeader;
     UCATableHeader *outHeader;
     UCATableHeader header;

     uint32_t count;

     /* argument checking in case we were not called from ucol_swap() */
     if(U_FAILURE(*pErrorCode)) {
         return 0;
     }
     if(ds==NULL || inData==NULL || length<-1 || (length>0 && outData==NULL)) {
         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }

     inBytes=(const uint8_t *)inData;
     outBytes=(uint8_t *)outData;

     inHeader=(const UCATableHeader *)inData;
     outHeader=(UCATableHeader *)outData;

     /*
      * The collation binary must contain at least the UCATableHeader,
      * starting with its size field.
      * sizeof(UCATableHeader)==42*4 in ICU 2.8
      * check the length against the header size before reading the size field
      */
     uprv_memset(&header, 0, sizeof(header));
     if(length<0) {
         header.size=udata_readInt32(ds, inHeader->size);
     } else if((length<(42*4) || length<(header.size=udata_readInt32(ds, inHeader->size)))) {
         udata_printError(ds, "ucol_swap(formatVersion=3): too few bytes (%d after header) for collation data\n",
                          length);
         *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
         return 0;
     }

     header.magic=ds->readUInt32(inHeader->magic);
     if(!(
         header.magic==UCOL_HEADER_MAGIC &&
         inHeader->formatVersion[0]==3 /*&&
         inHeader->formatVersion[1]>=0*/
     )) {
         udata_printError(ds, "ucol_swap(formatVersion=3): magic 0x%08x or format version %02x.%02x is not a collation binary\n",
                          header.magic,
                          inHeader->formatVersion[0], inHeader->formatVersion[1]);
         *pErrorCode=U_UNSUPPORTED_ERROR;
         return 0;
     }

     if(inHeader->isBigEndian!=ds->inIsBigEndian || inHeader->charSetFamily!=ds->inCharset) {
         udata_printError(ds, "ucol_swap(formatVersion=3): endianness %d or charset %d does not match the swapper\n",
                          inHeader->isBigEndian, inHeader->charSetFamily);
         *pErrorCode=U_INVALID_FORMAT_ERROR;
         return 0;
     }

     if(length>=0) {
         /* copy everything, takes care of data that needs no swapping */
         if(inBytes!=outBytes) {
             uprv_memcpy(outBytes, inBytes, header.size);
         }

         /* swap the necessary pieces in the order of their occurrence in the data */

         /* read more of the UCATableHeader (the size field was read above) */
         header.options=                 ds->readUInt32(inHeader->options);
         header.UCAConsts=               ds->readUInt32(inHeader->UCAConsts);
         header.contractionUCACombos=    ds->readUInt32(inHeader->contractionUCACombos);
         header.mappingPosition=         ds->readUInt32(inHeader->mappingPosition);
         header.expansion=               ds->readUInt32(inHeader->expansion);
         header.contractionIndex=        ds->readUInt32(inHeader->contractionIndex);
         header.contractionCEs=          ds->readUInt32(inHeader->contractionCEs);
         header.contractionSize=         ds->readUInt32(inHeader->contractionSize);
         header.endExpansionCE=          ds->readUInt32(inHeader->endExpansionCE);
         header.expansionCESize=         ds->readUInt32(inHeader->expansionCESize);
         header.endExpansionCECount=     udata_readInt32(ds, inHeader->endExpansionCECount);
         header.contractionUCACombosSize=udata_readInt32(ds, inHeader->contractionUCACombosSize);
         header.scriptToLeadByte=        ds->readUInt32(inHeader->scriptToLeadByte);
         header.leadByteToScript=        ds->readUInt32(inHeader->leadByteToScript);

         /* swap the 32-bit integers in the header */
         ds->swapArray32(ds, inHeader, (int32_t)((const char *)&inHeader->jamoSpecial-(const char *)inHeader),
                            outHeader, pErrorCode);
         ds->swapArray32(ds, &(inHeader->scriptToLeadByte), sizeof(header.scriptToLeadByte) + sizeof(header.leadByteToScript),
                            &(outHeader->scriptToLeadByte), pErrorCode);
         /* set the output platform properties */
         outHeader->isBigEndian=ds->outIsBigEndian;
         outHeader->charSetFamily=ds->outCharset;

         /* swap the options */
         if(header.options!=0) {
             ds->swapArray32(ds, inBytes+header.options, header.expansion-header.options,
                                outBytes+header.options, pErrorCode);
         }

         /* swap the expansions */
         if(header.mappingPosition!=0 && header.expansion!=0) {
             if(header.contractionIndex!=0) {
                 /* expansions bounded by contractions */
                 count=header.contractionIndex-header.expansion;
             } else {
                 /* no contractions: expansions bounded by the main trie */
                 count=header.mappingPosition-header.expansion;
             }
             ds->swapArray32(ds, inBytes+header.expansion, (int32_t)count,
                                outBytes+header.expansion, pErrorCode);
         }

         /* swap the contractions */
         if(header.contractionSize!=0) {
             /* contractionIndex: UChar[] */
             ds->swapArray16(ds, inBytes+header.contractionIndex, header.contractionSize*2,
                                outBytes+header.contractionIndex, pErrorCode);

             /* contractionCEs: CEs[] */
             ds->swapArray32(ds, inBytes+header.contractionCEs, header.contractionSize*4,
                                outBytes+header.contractionCEs, pErrorCode);
         }

         /* swap the main trie */
         if(header.mappingPosition!=0) {
             count=header.endExpansionCE-header.mappingPosition;
             utrie_swap(ds, inBytes+header.mappingPosition, (int32_t)count,
                           outBytes+header.mappingPosition, pErrorCode);
         }

         /* swap the max expansion table */
         if(header.endExpansionCECount!=0) {
             ds->swapArray32(ds, inBytes+header.endExpansionCE, header.endExpansionCECount*4,
                                outBytes+header.endExpansionCE, pErrorCode);
         }

         /* expansionCESize, unsafeCP, contrEndCP: uint8_t[], no need to swap */

         /* swap UCA constants */
         if(header.UCAConsts!=0) {
             /*
              * if UCAConsts!=0 then contractionUCACombos because we are swapping
              * the UCA data file, and we know that the UCA contains contractions
              */
             ds->swapArray32(ds, inBytes+header.UCAConsts, header.contractionUCACombos-header.UCAConsts,
                                outBytes+header.UCAConsts, pErrorCode);
         }

         /* swap UCA contractions */
         if(header.contractionUCACombosSize!=0) {
             count=header.contractionUCACombosSize*inHeader->contractionUCACombosWidth*U_SIZEOF_UCHAR;
             ds->swapArray16(ds, inBytes+header.contractionUCACombos, (int32_t)count,
                                outBytes+header.contractionUCACombos, pErrorCode);
         }

         /* swap the script to lead bytes */
         if(header.scriptToLeadByte!=0) {
             int indexCount = ds->readUInt16(*((uint16_t*)(inBytes+header.scriptToLeadByte))); // each entry = 2 * uint16
             int dataCount = ds->readUInt16(*((uint16_t*)(inBytes+header.scriptToLeadByte + 2))); // each entry = uint16
             ds->swapArray16(ds, inBytes+header.scriptToLeadByte,
                                 4 + (4 * indexCount) + (2 * dataCount),
                                 outBytes+header.scriptToLeadByte, pErrorCode);
         }

         /* swap the lead byte to scripts */
         if(header.leadByteToScript!=0) {
             int indexCount = ds->readUInt16(*((uint16_t*)(inBytes+header.leadByteToScript))); // each entry = uint16
             int dataCount = ds->readUInt16(*((uint16_t*)(inBytes+header.leadByteToScript + 2))); // each entry = uint16
             ds->swapArray16(ds, inBytes+header.leadByteToScript,
                                 4 + (2 * indexCount) + (2 * dataCount),
                                 outBytes+header.leadByteToScript, pErrorCode);
         }
     }

     return header.size;
 }

 // swap formatVersion 4 or 5 ----------------------------------------------- ***

 // The following are copied from CollationDataReader, trading an awkward copy of constants
 // for an awkward relocation of the i18n collationdatareader.h file into the common library.
 // Keep them in sync!

 enum {
     IX_INDEXES_LENGTH,  // 0
     IX_OPTIONS,
     IX_RESERVED2,
     IX_RESERVED3,

     IX_JAMO_CE32S_START,  // 4
     IX_REORDER_CODES_OFFSET,
     IX_REORDER_TABLE_OFFSET,
     IX_TRIE_OFFSET,

     IX_RESERVED8_OFFSET,  // 8
     IX_CES_OFFSET,
     IX_RESERVED10_OFFSET,
     IX_CE32S_OFFSET,

     IX_ROOT_ELEMENTS_OFFSET,  // 12
     IX_CONTEXTS_OFFSET,
     IX_UNSAFE_BWD_OFFSET,
     IX_FAST_LATIN_TABLE_OFFSET,

     IX_SCRIPTS_OFFSET,  // 16
     IX_COMPRESSIBLE_BYTES_OFFSET,
     IX_RESERVED18_OFFSET,
     IX_TOTAL_SIZE
 };

 int32_t
 swapFormatVersion4(const UDataSwapper *ds,
                    const void *inData, int32_t length, void *outData,
                    UErrorCode &errorCode) {
     if(U_FAILURE(errorCode)) { return 0; }

     const uint8_t *inBytes=(const uint8_t *)inData;
     uint8_t *outBytes=(uint8_t *)outData;

     const int32_t *inIndexes=(const int32_t *)inBytes;
     int32_t indexes[IX_TOTAL_SIZE+1];

     // Need at least IX_INDEXES_LENGTH and IX_OPTIONS.
     if(0<=length && length<8) {
         udata_printError(ds, "ucol_swap(formatVersion=4): too few bytes "
                          "(%d after header) for collation data\n",
                          length);
         errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
         return 0;
     }

     int32_t indexesLength=indexes[0]=udata_readInt32(ds, inIndexes[0]);
     if(0<=length && length<(indexesLength*4)) {
         udata_printError(ds, "ucol_swap(formatVersion=4): too few bytes "
                          "(%d after header) for collation data\n",
                          length);
         errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
         return 0;
     }

     for(int32_t i=1; i<=IX_TOTAL_SIZE && i<indexesLength; ++i) {
         indexes[i]=udata_readInt32(ds, inIndexes[i]);
     }
     for(int32_t i=indexesLength; i<=IX_TOTAL_SIZE; ++i) {
         indexes[i]=-1;
     }
     inIndexes=NULL;  // Make sure we do not accidentally use these instead of indexes[].

     // Get the total length of the data.
     int32_t size;
     if(indexesLength>IX_TOTAL_SIZE) {
         size=indexes[IX_TOTAL_SIZE];
     } else if(indexesLength>IX_REORDER_CODES_OFFSET) {
         size=indexes[indexesLength-1];
     } else {
         size=indexesLength*4;
     }
     if(length<0) { return size; }

     if(length<size) {
         udata_printError(ds, "ucol_swap(formatVersion=4): too few bytes "
                          "(%d after header) for collation data\n",
                          length);
         errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
         return 0;
     }

     // Copy the data for inaccessible bytes and arrays of bytes.
     if(inBytes!=outBytes) {
         uprv_memcpy(outBytes, inBytes, size);
     }

     // Swap the int32_t indexes[].
     ds->swapArray32(ds, inBytes, indexesLength * 4, outBytes, &errorCode);

     // The following is a modified version of CollationDataReader::read().
     // Here we use indexes[] not inIndexes[] because
     // the inIndexes[] may not be in this machine's endianness.
     int32_t index;  // one of the indexes[] slots
     int32_t offset;  // byte offset for the index part
     // int32_t length;  // number of bytes in the index part

     index = IX_REORDER_CODES_OFFSET;
     offset = indexes[index];
     length = indexes[index + 1] - offset;
     if(length > 0) {
         ds->swapArray32(ds, inBytes + offset, length, outBytes + offset, &errorCode);
     }

     // Skip the IX_REORDER_TABLE_OFFSET byte array.

     index = IX_TRIE_OFFSET;
     offset = indexes[index];
     length = indexes[index + 1] - offset;
     if(length > 0) {
         utrie2_swap(ds, inBytes + offset, length, outBytes + offset, &errorCode);
     }

     index = IX_RESERVED8_OFFSET;
     offset = indexes[index];
     length = indexes[index + 1] - offset;
     if(length > 0) {
         udata_printError(ds, "ucol_swap(formatVersion=4): unknown data at IX_RESERVED8_OFFSET\n", length);
         errorCode = U_UNSUPPORTED_ERROR;
         return 0;
     }

     index = IX_CES_OFFSET;
     offset = indexes[index];
     length = indexes[index + 1] - offset;
     if(length > 0) {
         ds->swapArray64(ds, inBytes + offset, length, outBytes + offset, &errorCode);
     }

     index = IX_RESERVED10_OFFSET;
     offset = indexes[index];
     length = indexes[index + 1] - offset;
     if(length > 0) {
         udata_printError(ds, "ucol_swap(formatVersion=4): unknown data at IX_RESERVED10_OFFSET\n", length);
         errorCode = U_UNSUPPORTED_ERROR;
         return 0;
     }

     index = IX_CE32S_OFFSET;
     offset = indexes[index];
     length = indexes[index + 1] - offset;
     if(length > 0) {
         ds->swapArray32(ds, inBytes + offset, length, outBytes + offset, &errorCode);
     }

     index = IX_ROOT_ELEMENTS_OFFSET;
     offset = indexes[index];
     length = indexes[index + 1] - offset;
     if(length > 0) {
         ds->swapArray32(ds, inBytes + offset, length, outBytes + offset, &errorCode);
     }

     index = IX_CONTEXTS_OFFSET;
     offset = indexes[index];
     length = indexes[index + 1] - offset;
     if(length > 0) {
         ds->swapArray16(ds, inBytes + offset, length, outBytes + offset, &errorCode);
     }

     index = IX_UNSAFE_BWD_OFFSET;
     offset = indexes[index];
     length = indexes[index + 1] - offset;
     if(length > 0) {
         ds->swapArray16(ds, inBytes + offset, length, outBytes + offset, &errorCode);
     }

     index = IX_FAST_LATIN_TABLE_OFFSET;
     offset = indexes[index];
     length = indexes[index + 1] - offset;
     if(length > 0) {
         ds->swapArray16(ds, inBytes + offset, length, outBytes + offset, &errorCode);
     }

     index = IX_SCRIPTS_OFFSET;
     offset = indexes[index];
     length = indexes[index + 1] - offset;
     if(length > 0) {
         ds->swapArray16(ds, inBytes + offset, length, outBytes + offset, &errorCode);
     }

     // Skip the  IX_COMPRESSIBLE_BYTES_OFFSET byte array.

     index = IX_RESERVED18_OFFSET;
     offset = indexes[index];
     length = indexes[index + 1] - offset;
     if(length > 0) {
         udata_printError(ds, "ucol_swap(formatVersion=4): unknown data at IX_RESERVED18_OFFSET\n", length);
         errorCode = U_UNSUPPORTED_ERROR;
         return 0;
     }

     return size;
 }

 }  // namespace

 /* swap ICU collation data like ucadata.icu */
 U_CAPI int32_t U_EXPORT2
 ucol_swap(const UDataSwapper *ds,
           const void *inData, int32_t length, void *outData,
           UErrorCode *pErrorCode) {
     if(U_FAILURE(*pErrorCode)) { return 0; }

     /* udata_swapDataHeader checks the arguments */
     int32_t headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
     if(U_FAILURE(*pErrorCode)) {
         // Try to swap the old format version which did not have a standard data header.
         *pErrorCode=U_ZERO_ERROR;
         return swapFormatVersion3(ds, inData, length, outData, pErrorCode);
     }

     /* check data format and format version */
     const UDataInfo &info=*(const UDataInfo *)((const char *)inData+4);
     if(!(
         info.dataFormat[0]==0x55 &&   // dataFormat="UCol"
         info.dataFormat[1]==0x43 &&
         info.dataFormat[2]==0x6f &&
         info.dataFormat[3]==0x6c &&
         (3<=info.formatVersion[0] && info.formatVersion[0]<=5)
     )) {
         udata_printError(ds, "ucol_swap(): data format %02x.%02x.%02x.%02x "
                          "(format version %02x.%02x) is not recognized as collation data\n",
                          info.dataFormat[0], info.dataFormat[1],
                          info.dataFormat[2], info.dataFormat[3],
                          info.formatVersion[0], info.formatVersion[1]);
         *pErrorCode=U_UNSUPPORTED_ERROR;
         return 0;
     }

     inData=(const char *)inData+headerSize;
     if(length>=0) { length-=headerSize; }
     outData=(char *)outData+headerSize;
     int32_t collationSize;
     if(info.formatVersion[0]>=4) {
         collationSize=swapFormatVersion4(ds, inData, length, outData, *pErrorCode);
     } else {
         collationSize=swapFormatVersion3(ds, inData, length, outData, pErrorCode);
     }
     if(U_SUCCESS(*pErrorCode)) {
         return headerSize+collationSize;
     } else {
         return 0;
     }
 }

 /* swap inverse UCA collation data (invuca.icu) */
 U_CAPI int32_t U_EXPORT2
 ucol_swapInverseUCA(const UDataSwapper *ds,
                     const void *inData, int32_t length, void *outData,
                     UErrorCode *pErrorCode) {
     const UDataInfo *pInfo;
     int32_t headerSize;

     const uint8_t *inBytes;
     uint8_t *outBytes;

     const InverseUCATableHeader *inHeader;
     InverseUCATableHeader *outHeader;
     InverseUCATableHeader header={ 0,0,0,0,0,{0,0,0,0},{0,0,0,0,0,0,0,0} };

     /* udata_swapDataHeader checks the arguments */
     headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
         return 0;
     }

     /* check data format and format version */
     pInfo=(const UDataInfo *)((const char *)inData+4);
     if(!(
         pInfo->dataFormat[0]==0x49 &&   /* dataFormat="InvC" */
         pInfo->dataFormat[1]==0x6e &&
         pInfo->dataFormat[2]==0x76 &&
         pInfo->dataFormat[3]==0x43 &&
         pInfo->formatVersion[0]==2 &&
         pInfo->formatVersion[1]>=1
     )) {
         udata_printError(ds, "ucol_swapInverseUCA(): data format %02x.%02x.%02x.%02x (format version %02x.%02x) is not an inverse UCA collation file\n",
                          pInfo->dataFormat[0], pInfo->dataFormat[1],
                          pInfo->dataFormat[2], pInfo->dataFormat[3],
                          pInfo->formatVersion[0], pInfo->formatVersion[1]);
         *pErrorCode=U_UNSUPPORTED_ERROR;
         return 0;
     }

     inBytes=(const uint8_t *)inData+headerSize;
     outBytes=(uint8_t *)outData+headerSize;

     inHeader=(const InverseUCATableHeader *)inBytes;
     outHeader=(InverseUCATableHeader *)outBytes;

     /*
      * The inverse UCA collation binary must contain at least the InverseUCATableHeader,
      * starting with its size field.
      * sizeof(UCATableHeader)==8*4 in ICU 2.8
      * check the length against the header size before reading the size field
      */
     if(length<0) {
         header.byteSize=udata_readInt32(ds, inHeader->byteSize);
     } else if(
         ((length-headerSize)<(8*4) ||
          (uint32_t)(length-headerSize)<(header.byteSize=udata_readInt32(ds, inHeader->byteSize)))
     ) {
         udata_printError(ds, "ucol_swapInverseUCA(): too few bytes (%d after header) for inverse UCA collation data\n",
                          length);
         *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
         return 0;
     }

     if(length>=0) {
         /* copy everything, takes care of data that needs no swapping */
         if(inBytes!=outBytes) {
             uprv_memcpy(outBytes, inBytes, header.byteSize);
         }

         /* swap the necessary pieces in the order of their occurrence in the data */

         /* read more of the InverseUCATableHeader (the byteSize field was read above) */
         header.tableSize=   ds->readUInt32(inHeader->tableSize);
         header.contsSize=   ds->readUInt32(inHeader->contsSize);
         header.table=       ds->readUInt32(inHeader->table);
         header.conts=       ds->readUInt32(inHeader->conts);

         /* swap the 32-bit integers in the header */
         ds->swapArray32(ds, inHeader, 5*4, outHeader, pErrorCode);

         /* swap the inverse table; tableSize counts uint32_t[3] rows */
         ds->swapArray32(ds, inBytes+header.table, header.tableSize*3*4,
                            outBytes+header.table, pErrorCode);

         /* swap the continuation table; contsSize counts UChars */
         ds->swapArray16(ds, inBytes+header.conts, header.contsSize*U_SIZEOF_UCHAR,
                            outBytes+header.conts, pErrorCode);
     }

     return headerSize+header.byteSize;
 }

 #endif /* #if !UCONFIG_NO_COLLATION */
	// © 2016 and later: Unicode, Inc. and others.
	// License & terms of use: http://www.unicode.org/copyright.html
	/*
	*******************************************************************************
	*
	* Copyright (C) 2003-2015, International Business Machines
	* Corporation and others. All Rights Reserved.
	*
	*******************************************************************************
	* file name: ucol_swp.cpp
	* encoding: UTF-8
	* tab size: 8 (not used)
	* indentation:4
	*
	* created on: 2003sep10
	* created by: Markus W. Scherer
	*
	* Swap collation binaries.
	*/

	#if defined(STARBOARD)
	#include "starboard/client_porting/poem/string_poem.h"
	#endif // defined(STARBOARD)
	#include "unicode/udata.h" /* UDataInfo */
	#include "utrie.h"
	#include "utrie2.h"
	#include "udataswp.h"
	#include "cmemory.h"
	#include "ucol_data.h"
	#include "ucol_swp.h"

	/* swapping ----------------------------------------------------------------- */

	#if !UCONFIG_NO_COLLATION

	U_CAPI UBool U_EXPORT2
	ucol_looksLikeCollationBinary(const UDataSwapper *ds,
	const void *inData, int32_t length) {
	if(ds==NULL \|\| inData==NULL \|\| length<-1) {
	return FALSE;
	}

	// First check for format version 4+ which has a standard data header.
	UErrorCode errorCode=U_ZERO_ERROR;
	(void)udata_swapDataHeader(ds, inData, -1, NULL, &errorCode);
	if(U_SUCCESS(errorCode)) {
	const UDataInfo &info=(const UDataInfo )((const char *)inData+4);
	if(info.dataFormat[0]==0x55 && // dataFormat="UCol"
	info.dataFormat[1]==0x43 &&
	info.dataFormat[2]==0x6f &&
	info.dataFormat[3]==0x6c) {
	return TRUE;
	}
	}

	// Else check for format version 3.
	const UCATableHeader inHeader=(const UCATableHeader )inData;

	/*
	* The collation binary must contain at least the UCATableHeader,
	* starting with its size field.
	* sizeof(UCATableHeader)==42*4 in ICU 2.8
	* check the length against the header size before reading the size field
	*/
	UCATableHeader header;
	uprv_memset(&header, 0, sizeof(header));
	if(length<0) {
	header.size=udata_readInt32(ds, inHeader->size);
	} else if((length<(42*4) \|\| length<(header.size=udata_readInt32(ds, inHeader->size)))) {
	return FALSE;
	}

	header.magic=ds->readUInt32(inHeader->magic);
	if(!(
	header.magic==UCOL_HEADER_MAGIC &&
	inHeader->formatVersion[0]==3 /*&&
	inHeader->formatVersion[1]>=0*/
	)) {
	return FALSE;
	}

	if(inHeader->isBigEndian!=ds->inIsBigEndian \|\| inHeader->charSetFamily!=ds->inCharset) {
	return FALSE;
	}

	return TRUE;
	}

	namespace {

	/* swap a header-less collation formatVersion=3 binary, inside a resource bundle or ucadata.icu */
	int32_t
	swapFormatVersion3(const UDataSwapper *ds,
	const void inData, int32_t length, void outData,
	UErrorCode *pErrorCode) {
	const uint8_t *inBytes;
	uint8_t *outBytes;

	const UCATableHeader *inHeader;
	UCATableHeader *outHeader;
	UCATableHeader header;

	uint32_t count;

	/* argument checking in case we were not called from ucol_swap() */
	if(U_FAILURE(*pErrorCode)) {
	return 0;
	}
	if(ds==NULL \|\| inData==NULL \|\| length<-1 \|\| (length>0 && outData==NULL)) {
	*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
	return 0;
	}

	inBytes=(const uint8_t *)inData;
	outBytes=(uint8_t *)outData;

	inHeader=(const UCATableHeader *)inData;
	outHeader=(UCATableHeader *)outData;

	/*
	* The collation binary must contain at least the UCATableHeader,
	* starting with its size field.
	* sizeof(UCATableHeader)==42*4 in ICU 2.8
	* check the length against the header size before reading the size field
	*/
	uprv_memset(&header, 0, sizeof(header));
	if(length<0) {
	header.size=udata_readInt32(ds, inHeader->size);
	} else if((length<(42*4) \|\| length<(header.size=udata_readInt32(ds, inHeader->size)))) {
	udata_printError(ds, "ucol_swap(formatVersion=3): too few bytes (%d after header) for collation data\n",
	length);
	*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
	return 0;
	}

	header.magic=ds->readUInt32(inHeader->magic);
	if(!(
	header.magic==UCOL_HEADER_MAGIC &&
	inHeader->formatVersion[0]==3 /*&&
	inHeader->formatVersion[1]>=0*/
	)) {
	udata_printError(ds, "ucol_swap(formatVersion=3): magic 0x%08x or format version %02x.%02x is not a collation binary\n",
	header.magic,
	inHeader->formatVersion[0], inHeader->formatVersion[1]);
	*pErrorCode=U_UNSUPPORTED_ERROR;
	return 0;
	}

	if(inHeader->isBigEndian!=ds->inIsBigEndian \|\| inHeader->charSetFamily!=ds->inCharset) {
	udata_printError(ds, "ucol_swap(formatVersion=3): endianness %d or charset %d does not match the swapper\n",
	inHeader->isBigEndian, inHeader->charSetFamily);
	*pErrorCode=U_INVALID_FORMAT_ERROR;
	return 0;
	}

	if(length>=0) {
	/* copy everything, takes care of data that needs no swapping */
	if(inBytes!=outBytes) {
	uprv_memcpy(outBytes, inBytes, header.size);
	}

	/* swap the necessary pieces in the order of their occurrence in the data */

	/* read more of the UCATableHeader (the size field was read above) */
	header.options= ds->readUInt32(inHeader->options);
	header.UCAConsts= ds->readUInt32(inHeader->UCAConsts);
	header.contractionUCACombos= ds->readUInt32(inHeader->contractionUCACombos);
	header.mappingPosition= ds->readUInt32(inHeader->mappingPosition);
	header.expansion= ds->readUInt32(inHeader->expansion);
	header.contractionIndex= ds->readUInt32(inHeader->contractionIndex);
	header.contractionCEs= ds->readUInt32(inHeader->contractionCEs);
	header.contractionSize= ds->readUInt32(inHeader->contractionSize);
	header.endExpansionCE= ds->readUInt32(inHeader->endExpansionCE);
	header.expansionCESize= ds->readUInt32(inHeader->expansionCESize);
	header.endExpansionCECount= udata_readInt32(ds, inHeader->endExpansionCECount);
	header.contractionUCACombosSize=udata_readInt32(ds, inHeader->contractionUCACombosSize);
	header.scriptToLeadByte= ds->readUInt32(inHeader->scriptToLeadByte);
	header.leadByteToScript= ds->readUInt32(inHeader->leadByteToScript);

	/* swap the 32-bit integers in the header */
	ds->swapArray32(ds, inHeader, (int32_t)((const char )&inHeader->jamoSpecial-(const char )inHeader),
	outHeader, pErrorCode);
	ds->swapArray32(ds, &(inHeader->scriptToLeadByte), sizeof(header.scriptToLeadByte) + sizeof(header.leadByteToScript),
	&(outHeader->scriptToLeadByte), pErrorCode);
	/* set the output platform properties */
	outHeader->isBigEndian=ds->outIsBigEndian;
	outHeader->charSetFamily=ds->outCharset;

	/* swap the options */
	if(header.options!=0) {
	ds->swapArray32(ds, inBytes+header.options, header.expansion-header.options,
	outBytes+header.options, pErrorCode);
	}

	/* swap the expansions */
	if(header.mappingPosition!=0 && header.expansion!=0) {
	if(header.contractionIndex!=0) {
	/* expansions bounded by contractions */
	count=header.contractionIndex-header.expansion;
	} else {
	/* no contractions: expansions bounded by the main trie */
	count=header.mappingPosition-header.expansion;
	}
	ds->swapArray32(ds, inBytes+header.expansion, (int32_t)count,
	outBytes+header.expansion, pErrorCode);
	}

	/* swap the contractions */
	if(header.contractionSize!=0) {
	/* contractionIndex: UChar[] */
	ds->swapArray16(ds, inBytes+header.contractionIndex, header.contractionSize*2,
	outBytes+header.contractionIndex, pErrorCode);

	/* contractionCEs: CEs[] */
	ds->swapArray32(ds, inBytes+header.contractionCEs, header.contractionSize*4,
	outBytes+header.contractionCEs, pErrorCode);
	}

	/* swap the main trie */
	if(header.mappingPosition!=0) {
	count=header.endExpansionCE-header.mappingPosition;
	utrie_swap(ds, inBytes+header.mappingPosition, (int32_t)count,
	outBytes+header.mappingPosition, pErrorCode);
	}

	/* swap the max expansion table */
	if(header.endExpansionCECount!=0) {
	ds->swapArray32(ds, inBytes+header.endExpansionCE, header.endExpansionCECount*4,
	outBytes+header.endExpansionCE, pErrorCode);
	}

	/* expansionCESize, unsafeCP, contrEndCP: uint8_t[], no need to swap */

	/* swap UCA constants */
	if(header.UCAConsts!=0) {
	/*
	* if UCAConsts!=0 then contractionUCACombos because we are swapping
	* the UCA data file, and we know that the UCA contains contractions
	*/
	ds->swapArray32(ds, inBytes+header.UCAConsts, header.contractionUCACombos-header.UCAConsts,
	outBytes+header.UCAConsts, pErrorCode);
	}

	/* swap UCA contractions */
	if(header.contractionUCACombosSize!=0) {
	count=header.contractionUCACombosSizeinHeader->contractionUCACombosWidthU_SIZEOF_UCHAR;
	ds->swapArray16(ds, inBytes+header.contractionUCACombos, (int32_t)count,
	outBytes+header.contractionUCACombos, pErrorCode);
	}

	/* swap the script to lead bytes */
	if(header.scriptToLeadByte!=0) {
	int indexCount = ds->readUInt16(((uint16_t)(inBytes+header.scriptToLeadByte))); // each entry = 2 * uint16
	int dataCount = ds->readUInt16(((uint16_t)(inBytes+header.scriptToLeadByte + 2))); // each entry = uint16
	ds->swapArray16(ds, inBytes+header.scriptToLeadByte,
	4 + (4 * indexCount) + (2 * dataCount),
	outBytes+header.scriptToLeadByte, pErrorCode);
	}

	/* swap the lead byte to scripts */
	if(header.leadByteToScript!=0) {
	int indexCount = ds->readUInt16(((uint16_t)(inBytes+header.leadByteToScript))); // each entry = uint16
	int dataCount = ds->readUInt16(((uint16_t)(inBytes+header.leadByteToScript + 2))); // each entry = uint16
	ds->swapArray16(ds, inBytes+header.leadByteToScript,
	4 + (2 * indexCount) + (2 * dataCount),
	outBytes+header.leadByteToScript, pErrorCode);
	}
	}

	return header.size;
	}

	// swap formatVersion 4 or 5 ----------------------------------------------- ***

	// The following are copied from CollationDataReader, trading an awkward copy of constants
	// for an awkward relocation of the i18n collationdatareader.h file into the common library.
	// Keep them in sync!

	enum {
	IX_INDEXES_LENGTH, // 0
	IX_OPTIONS,
	IX_RESERVED2,
	IX_RESERVED3,

	IX_JAMO_CE32S_START, // 4
	IX_REORDER_CODES_OFFSET,
	IX_REORDER_TABLE_OFFSET,
	IX_TRIE_OFFSET,

	IX_RESERVED8_OFFSET, // 8
	IX_CES_OFFSET,
	IX_RESERVED10_OFFSET,
	IX_CE32S_OFFSET,

	IX_ROOT_ELEMENTS_OFFSET, // 12
	IX_CONTEXTS_OFFSET,
	IX_UNSAFE_BWD_OFFSET,
	IX_FAST_LATIN_TABLE_OFFSET,

	IX_SCRIPTS_OFFSET, // 16
	IX_COMPRESSIBLE_BYTES_OFFSET,
	IX_RESERVED18_OFFSET,
	IX_TOTAL_SIZE
	};

	int32_t
	swapFormatVersion4(const UDataSwapper *ds,
	const void inData, int32_t length, void outData,
	UErrorCode &errorCode) {
	if(U_FAILURE(errorCode)) { return 0; }

	const uint8_t inBytes=(const uint8_t )inData;
	uint8_t outBytes=(uint8_t )outData;

	const int32_t inIndexes=(const int32_t )inBytes;
	int32_t indexes[IX_TOTAL_SIZE+1];

	// Need at least IX_INDEXES_LENGTH and IX_OPTIONS.
	if(0<=length && length<8) {
	udata_printError(ds, "ucol_swap(formatVersion=4): too few bytes "
	"(%d after header) for collation data\n",
	length);
	errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
	return 0;
	}

	int32_t indexesLength=indexes[0]=udata_readInt32(ds, inIndexes[0]);
	if(0<=length && length<(indexesLength*4)) {
	udata_printError(ds, "ucol_swap(formatVersion=4): too few bytes "
	"(%d after header) for collation data\n",
	length);
	errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
	return 0;
	}

	for(int32_t i=1; i<=IX_TOTAL_SIZE && i<indexesLength; ++i) {
	indexes[i]=udata_readInt32(ds, inIndexes[i]);
	}
	for(int32_t i=indexesLength; i<=IX_TOTAL_SIZE; ++i) {
	indexes[i]=-1;
	}
	inIndexes=NULL; // Make sure we do not accidentally use these instead of indexes[].

	// Get the total length of the data.
	int32_t size;
	if(indexesLength>IX_TOTAL_SIZE) {
	size=indexes[IX_TOTAL_SIZE];
	} else if(indexesLength>IX_REORDER_CODES_OFFSET) {
	size=indexes[indexesLength-1];
	} else {
	size=indexesLength*4;
	}
	if(length<0) { return size; }

	if(length<size) {
	udata_printError(ds, "ucol_swap(formatVersion=4): too few bytes "
	"(%d after header) for collation data\n",
	length);
	errorCode=U_INDEX_OUTOFBOUNDS_ERROR;
	return 0;
	}

	// Copy the data for inaccessible bytes and arrays of bytes.
	if(inBytes!=outBytes) {
	uprv_memcpy(outBytes, inBytes, size);
	}

	// Swap the int32_t indexes[].
	ds->swapArray32(ds, inBytes, indexesLength * 4, outBytes, &errorCode);

	// The following is a modified version of CollationDataReader::read().
	// Here we use indexes[] not inIndexes[] because
	// the inIndexes[] may not be in this machine's endianness.
	int32_t index; // one of the indexes[] slots
	int32_t offset; // byte offset for the index part
	// int32_t length; // number of bytes in the index part

	index = IX_REORDER_CODES_OFFSET;
	offset = indexes[index];
	length = indexes[index + 1] - offset;
	if(length > 0) {
	ds->swapArray32(ds, inBytes + offset, length, outBytes + offset, &errorCode);
	}

	// Skip the IX_REORDER_TABLE_OFFSET byte array.

	index = IX_TRIE_OFFSET;
	offset = indexes[index];
	length = indexes[index + 1] - offset;
	if(length > 0) {
	utrie2_swap(ds, inBytes + offset, length, outBytes + offset, &errorCode);
	}

	index = IX_RESERVED8_OFFSET;
	offset = indexes[index];
	length = indexes[index + 1] - offset;
	if(length > 0) {
	udata_printError(ds, "ucol_swap(formatVersion=4): unknown data at IX_RESERVED8_OFFSET\n", length);
	errorCode = U_UNSUPPORTED_ERROR;
	return 0;
	}

	index = IX_CES_OFFSET;
	offset = indexes[index];
	length = indexes[index + 1] - offset;
	if(length > 0) {
	ds->swapArray64(ds, inBytes + offset, length, outBytes + offset, &errorCode);
	}

	index = IX_RESERVED10_OFFSET;
	offset = indexes[index];
	length = indexes[index + 1] - offset;
	if(length > 0) {
	udata_printError(ds, "ucol_swap(formatVersion=4): unknown data at IX_RESERVED10_OFFSET\n", length);
	errorCode = U_UNSUPPORTED_ERROR;
	return 0;
	}

	index = IX_CE32S_OFFSET;
	offset = indexes[index];
	length = indexes[index + 1] - offset;
	if(length > 0) {
	ds->swapArray32(ds, inBytes + offset, length, outBytes + offset, &errorCode);
	}

	index = IX_ROOT_ELEMENTS_OFFSET;
	offset = indexes[index];
	length = indexes[index + 1] - offset;
	if(length > 0) {
	ds->swapArray32(ds, inBytes + offset, length, outBytes + offset, &errorCode);
	}

	index = IX_CONTEXTS_OFFSET;
	offset = indexes[index];
	length = indexes[index + 1] - offset;
	if(length > 0) {
	ds->swapArray16(ds, inBytes + offset, length, outBytes + offset, &errorCode);
	}

	index = IX_UNSAFE_BWD_OFFSET;
	offset = indexes[index];
	length = indexes[index + 1] - offset;
	if(length > 0) {
	ds->swapArray16(ds, inBytes + offset, length, outBytes + offset, &errorCode);
	}

	index = IX_FAST_LATIN_TABLE_OFFSET;
	offset = indexes[index];
	length = indexes[index + 1] - offset;
	if(length > 0) {
	ds->swapArray16(ds, inBytes + offset, length, outBytes + offset, &errorCode);
	}

	index = IX_SCRIPTS_OFFSET;
	offset = indexes[index];
	length = indexes[index + 1] - offset;
	if(length > 0) {
	ds->swapArray16(ds, inBytes + offset, length, outBytes + offset, &errorCode);
	}

	// Skip the IX_COMPRESSIBLE_BYTES_OFFSET byte array.

	index = IX_RESERVED18_OFFSET;
	offset = indexes[index];
	length = indexes[index + 1] - offset;
	if(length > 0) {
	udata_printError(ds, "ucol_swap(formatVersion=4): unknown data at IX_RESERVED18_OFFSET\n", length);
	errorCode = U_UNSUPPORTED_ERROR;
	return 0;
	}

	return size;
	}

	} // namespace

	/* swap ICU collation data like ucadata.icu */
	U_CAPI int32_t U_EXPORT2
	ucol_swap(const UDataSwapper *ds,
	const void inData, int32_t length, void outData,
	UErrorCode *pErrorCode) {
	if(U_FAILURE(*pErrorCode)) { return 0; }

	/* udata_swapDataHeader checks the arguments */
	int32_t headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
	if(U_FAILURE(*pErrorCode)) {
	// Try to swap the old format version which did not have a standard data header.
	*pErrorCode=U_ZERO_ERROR;
	return swapFormatVersion3(ds, inData, length, outData, pErrorCode);
	}

	/* check data format and format version */
	const UDataInfo &info=(const UDataInfo )((const char *)inData+4);
	if(!(
	info.dataFormat[0]==0x55 && // dataFormat="UCol"
	info.dataFormat[1]==0x43 &&
	info.dataFormat[2]==0x6f &&
	info.dataFormat[3]==0x6c &&
	(3<=info.formatVersion[0] && info.formatVersion[0]<=5)
	)) {
	udata_printError(ds, "ucol_swap(): data format %02x.%02x.%02x.%02x "
	"(format version %02x.%02x) is not recognized as collation data\n",
	info.dataFormat[0], info.dataFormat[1],
	info.dataFormat[2], info.dataFormat[3],
	info.formatVersion[0], info.formatVersion[1]);
	*pErrorCode=U_UNSUPPORTED_ERROR;
	return 0;
	}

	inData=(const char *)inData+headerSize;
	if(length>=0) { length-=headerSize; }
	outData=(char *)outData+headerSize;
	int32_t collationSize;
	if(info.formatVersion[0]>=4) {
	collationSize=swapFormatVersion4(ds, inData, length, outData, *pErrorCode);
	} else {
	collationSize=swapFormatVersion3(ds, inData, length, outData, pErrorCode);
	}
	if(U_SUCCESS(*pErrorCode)) {
	return headerSize+collationSize;
	} else {
	return 0;
	}
	}

	/* swap inverse UCA collation data (invuca.icu) */
	U_CAPI int32_t U_EXPORT2
	ucol_swapInverseUCA(const UDataSwapper *ds,
	const void inData, int32_t length, void outData,
	UErrorCode *pErrorCode) {
	const UDataInfo *pInfo;
	int32_t headerSize;

	const uint8_t *inBytes;
	uint8_t *outBytes;

	const InverseUCATableHeader *inHeader;
	InverseUCATableHeader *outHeader;
	InverseUCATableHeader header={ 0,0,0,0,0,{0,0,0,0},{0,0,0,0,0,0,0,0} };

	/* udata_swapDataHeader checks the arguments */
	headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
	if(pErrorCode==NULL \|\| U_FAILURE(*pErrorCode)) {
	return 0;
	}

	/* check data format and format version */
	pInfo=(const UDataInfo )((const char )inData+4);
	if(!(
	pInfo->dataFormat[0]==0x49 && /* dataFormat="InvC" */
	pInfo->dataFormat[1]==0x6e &&
	pInfo->dataFormat[2]==0x76 &&
	pInfo->dataFormat[3]==0x43 &&
	pInfo->formatVersion[0]==2 &&
	pInfo->formatVersion[1]>=1
	)) {
	udata_printError(ds, "ucol_swapInverseUCA(): data format %02x.%02x.%02x.%02x (format version %02x.%02x) is not an inverse UCA collation file\n",
	pInfo->dataFormat[0], pInfo->dataFormat[1],
	pInfo->dataFormat[2], pInfo->dataFormat[3],
	pInfo->formatVersion[0], pInfo->formatVersion[1]);
	*pErrorCode=U_UNSUPPORTED_ERROR;
	return 0;
	}

	inBytes=(const uint8_t *)inData+headerSize;
	outBytes=(uint8_t *)outData+headerSize;

	inHeader=(const InverseUCATableHeader *)inBytes;
	outHeader=(InverseUCATableHeader *)outBytes;

	/*
	* The inverse UCA collation binary must contain at least the InverseUCATableHeader,
	* starting with its size field.
	* sizeof(UCATableHeader)==8*4 in ICU 2.8
	* check the length against the header size before reading the size field
	*/
	if(length<0) {
	header.byteSize=udata_readInt32(ds, inHeader->byteSize);
	} else if(
	((length-headerSize)<(8*4) \|\|
	(uint32_t)(length-headerSize)<(header.byteSize=udata_readInt32(ds, inHeader->byteSize)))
	) {
	udata_printError(ds, "ucol_swapInverseUCA(): too few bytes (%d after header) for inverse UCA collation data\n",
	length);
	*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
	return 0;
	}

	if(length>=0) {
	/* copy everything, takes care of data that needs no swapping */
	if(inBytes!=outBytes) {
	uprv_memcpy(outBytes, inBytes, header.byteSize);
	}

	/* swap the necessary pieces in the order of their occurrence in the data */

	/* read more of the InverseUCATableHeader (the byteSize field was read above) */
	header.tableSize= ds->readUInt32(inHeader->tableSize);
	header.contsSize= ds->readUInt32(inHeader->contsSize);
	header.table= ds->readUInt32(inHeader->table);
	header.conts= ds->readUInt32(inHeader->conts);

	/* swap the 32-bit integers in the header */
	ds->swapArray32(ds, inHeader, 5*4, outHeader, pErrorCode);

	/* swap the inverse table; tableSize counts uint32_t[3] rows */
	ds->swapArray32(ds, inBytes+header.table, header.tableSize34,
	outBytes+header.table, pErrorCode);

	/* swap the continuation table; contsSize counts UChars */
	ds->swapArray16(ds, inBytes+header.conts, header.contsSize*U_SIZEOF_UCHAR,
	outBytes+header.conts, pErrorCode);
	}

	return headerSize+header.byteSize;
	}

	#endif /* #if !UCONFIG_NO_COLLATION */