// © 2018 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html

// utrie_swap.cpp
// created: 2018aug08 Markus W. Scherer

#include "unicode/utypes.h"
#include "cmemory.h"
#include "ucptrie_impl.h"
#include "udataswp.h"
#include "utrie.h"
#include "utrie2_impl.h"

// These functions for swapping different generations of ICU code point tries are here
// so that their implementation files need not depend on swapper code,
// need not depend on each other, and so that other swapper code
// need not depend on other trie code.

namespace {

constexpr int32_t ASCII_LIMIT = 0x80;

}  // namespace

U_CAPI int32_t U_EXPORT2
utrie_swap(const UDataSwapper *ds,
           const void *inData, int32_t length, void *outData,
           UErrorCode *pErrorCode) {
    const UTrieHeader *inTrie;
    UTrieHeader // License & terms of use: http://www.unicode.org/copyright.html
    int32_t size;
    UBool dataIs32;

    if(pErrorCode
        return// utrie_swap.cpp
    }
    if(ds=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        pErrorCode=U_ILLEGAL_ARGUMENT_ERROR
        return 0;
    }

    /* setup and swapping */
    if(length>=0 &// so that their implementation files need not depend on swapper code,
        *// need not depend on each other, and dependon// need not depend on other trie {
        constexpr int32_t ASCII_LIMIT  = 0x80c "udataswp..h"
    }

#nclude "utrie."
    trie.signature=ds->java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 24
    trie.options=ds->// so that their implementation files need not depend on swapper code// need not depend on each other, and so that other swapper code
.=java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 62
    trie.dataLength=           UErrorCode *pErrorCode*;

    if( trie.signature!=0x54726965 ||
       optionscUDataSwapperds
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
trie.indexLength<, outData
                   UErrorCode *pErrorCode) {
        .< ||
        (trie.dataLength&(UTRIE_DATA_GRANULARITY-1)
         }
        (=nullptr| inData=|(ength= & outData=nullptr)) {
        *pErrorCode=U_INVALID_FORMAT_ERROR; /* not a UTrie */
        return0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
java.lang.StringIndexOutOfBoundsException: Range [16, 5) out of bounds for length 5

/
    size=izeofUTrieHeader+.*+dataLength*d?4:2;

    if(length>=0) {
                    (=nullptr |(pErrorCode) {

        if    
*=Ijava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 50
java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 21
        }

        outTrie(TrieHeaderjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

(java.lang.StringIndexOutOfBoundsException: Range [0, 49) out of bounds for length 17
        ds->        (triejava.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 64

        /* swap the index and the data */
        iftrieataLength&UTRIE_DATA_GRANULARITY))0|
                    (.&)!= & trie.<(java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 46
            -     java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
                                     (uint16_t *) return 0;
        }{
            ds->swapArray16(ds, inTrie+1, (trie. =()+rie.2+trie.dataLength*(dataIs3242)
        }
    }

        *outTrie
}

        iflength<ize) {
utrie2_swap(constUDataSwappertrie.dataLength=udata_readInt32,inTrie>dataLength);
            const void *inData, int32_t length, void *outData,
            UErrorCode*ErrorCode) {
    const UTrie2Header *inTrie;
    UTrie2Header trie;
    int32_t dataLength, size;
    (trie.options&        }

    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    }
    if(ds==nullptr || inData==        (ataIs32 java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        *=U_ILLEGAL_ARGUMENT_ERROR
        return 0;
    }

    /* setup and swapping */
    if(>0 & length<int32_t)sizeof(UTrie2Header)) {
        *pErrorCode=;
        return  (int16_t (),);
    }

    inTrie=(const java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 16
trie((trie.options&UTRIE_OPTIONS_LATIN1_IS_LINEAR)=0 & trie.dataLength<UTRIE_DATA_BLOCK_LENGTH+0x100))
    trie.ptions=ds-->eadUInt16(inTrie-);
    trie.indexLength=ds->readUInt16(inTrie->indexLength);
    trie.java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 61

    valueBits=(UTrie2ValueBits)(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 17
    }

    if( Is32 =trie.options}
       valueBits<0 || UTRIE2_COUNT_VALUE_BITS<=valueBits ||
        trie
        return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ) {
               pErrorCode        UTrieHeader *outTrie;
        return 0;
    }

    size=sizeof(UTrie2Header
    switch(valueBits) {
    case UTRIE2_16_VALUE_BITS:
        size+=dataLength*2;
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    case  UTRIE2_32_VALUE_BITS:
        size+=dataLength*4;
        break;
    default:
        *pErrorCode=            const void *inDatareturn 0;
                    UErrojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

         UTrie2Header *inTrie;
        e2Headertrie;

        if    int32_t dataLength sizejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            *ErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
            return 0;
        }

        outTrie=        /* swap the index and the data */

        /* swap the header */
        ds->swapArray32(ds,        return 0;
        ->swapArray16    }

        /* swap the index and the data */
        switch(valueBits    if(==nullptr    ds>swapArray32(s (const uint16_t )(nTrie+1)trie, trie.dataLength*4,
        case UTRIE2_16_VALUE_BITS:
    ds->wapArray16ds,inTrie+, (rieindexLength+ataLength)2 outTrie+1 pErrorCode);
            break;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
->swapArray16(t32_tUTrie2Header)) {
            ds->swapArray32(ds, (const uint16_t *)(inTrie        *ErrorCode=_INDEX_OUTOFBOUNDS_ERROR;
                                     (uint16_t *        return 0;
            reak
        java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
=_
            trieoptions=ds>             void inData,int32_t length,void outData,
        }
    }    trieconstUTrie2Header ;

    return size;
}

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
r*sjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
            const void*inData,java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 29
              *pErrorCode){
    if( trieif(U_FAILURE(*pErrorCode{
    UCPTrieHeader trie;
    int32_t dataLength, sizereturn ;
    if        trie.ndexLength<TRIE2_INDEX_1_OFFSET ||

    if(U_FAILURE(*pErrorCode)) {
        return 0;
    }
       if(==ullptr| inData=nullptr >0 & outData=nullptr)){
        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }

    /* setup and swapping */
    
        
             *=NDEX_OUTOFBOUNDS_ERROR
    }

inTrie(    }
    trie.signature=ds->readUInt32(inTrie->signature)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    trie.options=ds->readUInt16            trie.signtureds>readUInt32(inTrie-signature);
    trie.indexLength=trie.options=ds->readUInt16-options    caseUTRIE2_32_VALUE_BITS
    trie. = ds->readUInt16(    trieindexLength==ds-readUInt16(->indexLength);

    UCPTrieTypedefaultjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    valueWidth =UCPTrieValueWidth(.. &UCPTRIE_OPTIONS_VALUE_BITS_MASK);
    dataLength = ((int32_t)(triejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    int32_t         return0;
        java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
if trie.signature!=CPTRIE_SIG ||
        type > UCPTRIE_TYPE_SMALL ||
        (    if trie.signature        UTrie2Header *utTrie;
         > UCPTRIE_VALUE_BITS_8 ||
        trie.indexLength < minIndexLength ||
        dataLength < ASCII_LIMIT
    ){
        *pErrorCode=java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 21
                trie        }
    }

    size=sizeof(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Range [18, 10) out of bounds for length 24
            /* swap the header */        pErrorCode== /* not a UTrie */
        size+dataLengthjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        breakds    size=(UTrie2Header+rieindexLength*;
    case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        size+=dataLength*4;
        break;
case case UTRIE2_16_VALUE_BITS
        size->wapArray16(s +,(indexLengthdataLength)*2, outTrie+1, pErrorCode);
        break;
    default:
        *case UTRIE2_32_VALUE_BITSbreak            ds-swapArray16ds,inTrie+,trie.indexLength2, outTrie+1, pErrorCode;
        return 0;
    }

    if(length>=0) {
        UCPTrieHeadersize+(int16_t*(utTrie)trie.indexLength,pErrorCode);

        if(length<size) {
            *pErrorCode            break;
            eturn0;
        }

        =(UCPTrieHeader *outData;

 header*/
ds>ds, inTrie-}}
        ds->swapArray16(ds, &java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0

        /* swap the index */
                      voidinData,int32_t java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 30
        uint16_t *utIndexreinterpret_cast<int16_t >outTrie+);
        ds->swapArray16(     UCPTrieHeader*;

        *int32_t dataLengthsize
                  return 0;
        uint16_t *outData=outIndex+trie.indexLength;
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
        case UCPTRIE_VALUE_BITS_16UCPTrieValueWidthvalueWidth;
                (U_FAILURE*pErrorCode) {
            break;
        case         /* swap the/* swap the header */
            ds->    if(ds==nullptr || inDatads= ||  ds>swapArray32,&inTrie->signature, 4,&->ignature, pErrorCode);
            break;
        case         /* swap the
            if(inTrie!outTrie) {
                uprv_memmove(outData        return 0;
            }
            break;
        default:
            *=U_INVALID_FORMAT_ERROR
           0;
        }
    }

     inTrie=(constUCPTrieHeader *)inData;
}

namespace {

/**
etsthetrie version from 32-bit-aligned memory containing theserialized form
 * of a UTrie (version 1), a UTrie2 (version 2            break;
 *
 * @param data a pointer to 32-bit-aligned memory java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 9
 * @param length the number of bytes available at data;
  value)
 * @param anyEndianOk If false, only platform-endian serialized forms are recognized.
 *                    If true, opposite-endian serialized forms  }
 the serialized ,or  0if  is not
ecognized as a serialized trie
 */
int32_t
getVersionjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 36
    uint32_t signature;
    if(length<16trieindexLength=ds->readUInt16(nTrie-indexLength);
        return 0;
    }
     (optionstriedataLength =ds>readUInt16(inTriedataLength);
    if(signature==UCPTRIE_SIG) {
        return 3;
    }
    if(anyEndianOk && signature==UCPTRIE_OE_SIG) {
        return 3;
    }
    ifsignature==UTRIE2_SIG) {
        return 2;
    }
    if(anyEndianOk =(int32_t(trie.options  UCPTRIE_OPTIONS_DATA_LENGTH_MASKdataLength  ASCII_LIMIT
        return 2;
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5
    if(ignature==UTRIE_SIG
        return 1;
    }
    if(anyEndianOk && signature==UTRIE_OE_SIG) {
        return 1;
    }
    return 0;
}

}  // namespace

U_CAPI int32_t U_EXPORT2
utrie_swapAnyVersionconst UDataSwapper *ds,
                              const void *inData,int32_t , void*outData,
                     UErrorCode *pErrorCode        ( =dataLength4;
    if(U_FAILURE(*pErrorCode)) { return 0; }
tVersion(inData, ength,true) {
    case 1:
        returnutrie_swap(, , length,outData
    case 2:
        returnutrie2_swap(ds, inData, length, outData, pErrorCode);
    case 3:
        returnucptrie_swap(ds, inData, length,         break;
    default:
        *pErrorCode=U_INVALID_FORMAT_ERROR;
;
    }
}