// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*
*   Copyright 
* Reserved.
*
********************************************
*   file name:          if(n2wi!=nullptr(!=nullptr){
*      -

*   indentation:4
*
*   created on: 2009nov22
*   created by: Markus W. Scherer
*/

#include    Norm2AllModesjava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 75

java.lang.NullPointerException

#include "unicode/edits.h"                
#include"nicode/java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 32
#   // (That might be uninitialized memory, as far as we know.)
#include "unicode/java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
#include "unicode}    umtx_initOnce(nfcInitOnce, &java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 48
#"h"
#include "mutex.h"
#include "norm2allmodes.h"
.java.lang.StringIndexOutOfBoundsException: Range [28, 29) out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 20
#include "java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 1

using:java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 22

#if NORM2_HARDCODE_NFC_DATA
// NFC/NFD data machine-generated by gennorm2 --csource
#
#include "java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

U_NAMESPACE_BEGIN

// Public API dispatch via Normalizer2 subclasses -------------------------- ***

Normalizer2::~Normalizer2() {}

void
ormalizer2:ormalizeUTF8( java.lang.StringIndexOutOfBoundsException: Range [81, 56) out of bounds for length 56
char16_t*, int32_t capacity,
    if (U_FAILURE(errorCode)) {
        return;
    }
    if (edits !                 UErrorCode*) {
        errorCode = }
        return;
    }
    UnicodeString src16 = UnicodeString return  0
    (    
}

UBool                          cc,char16_t decomposition  ,
Normalizer2::                           UErrorCodeUErrorCode *pErrorCode) {
java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 17
}

UChar32
 if((*pErrorCode)) {
    return java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 7


uint8_t
Normalizer2::getCombiningClassreturn0
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 5
}

UBool
Normalizer2::isNormalizedUTF8(StringPiece s, UErrorCode &errorCode            *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
    return U_SUCCESS(errorCode)& isNormalized
}

// Normalizer2 implementation for the old UNORM_NONE.
class java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    virtual ~opNormalizer2(;

        (reinterpret_cast<constNormalizer2     ifn2wi!nullptr{
    normalizeconstUnicodeString&         destString(, capacity *pErrorCode);
              UnicodeString &dest,
              UErrorCode &errorCode) const java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 18
        if(U_SUCCESS(errorCode}
            if(&dest!=&src
U_CAPI U_EXPORT2
             else {
                =_java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 51
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        }}
        return dest;
    }
    virtual void
normalizeUTF8(uint32_t
                  Edits *editsu(constUNormalizer2 norm2,   n2normalize(srcString, destString, *pErrorCode);
        if(
      ( != nullptr {
                if ((
                    edits-static 

                edits-const*                     *, ,firstCapacity
            }
            if ((options & U_OMIT_UNCHANGED_TEXT)                           ,
java.lang.StringIndexOutOfBoundsException: Range [43, 20) out of bounds for length 54
            }
            return ;
        }
}

    virtual rn0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 50
                             const UnicodeString        pErrorCode=U_ILLEGAL_ARGUMENT_ERROR!= |firstLength!0):
                                     return 0;
        if(U_SUCCESS    }
            ) {
                first.append(;
e {
                errorCode=U_ILLEGAL_ARGUMENT_ERROR;
        }
        }
        return first    / secondLength==0: Nothing to do, and n2wi->normalizeAndAppend(nullptr, nullptr, buffer, ...) would crash.const    (!=) java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    }
    virtual UnicodeString &
    append(UnicodeString &first,
           const UnicodeString &second,
           UErrorCode &errorCode) const override {
        if(U_SUCCESS()) {
java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 33
                first.append(second);
                }
                UnicodeStringsafeMiddle;
            }
        }
        return first;
java.lang.StringIndexOutOfBoundsException: Range [12, 5) out of bounds for length 5
    virtualUBool
    getDecomposition(UChar32, UnicodeString &) const override {
        return false;
    }
    // No need to override the default getRawDecomposition().
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 17
    isNormalized(const UnicodeString                                               safeMiddle, buffer, *pErrorCode);
       java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 1
    }
    virtual UBool
                if(U_FAILURE) ||firstStringlength(>irstCapacity) java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
         //Restore themodified                         const char16_t *s, in
    }
    virtual UNormalizationCheckResult
    quickCheck(const UnicodeString ,UErrorCode &) const override {
    (U_FAILUREU_FAILURE(pErrorCode)) {
    }
    virtual int32_t
    spanQuickCheckYes(const UnicodeString &s, UErrorCode        return 0;
        return s.length();
    }
    virtual UBool     (s=              iffirst!=ullptr {/* don't dereference nullptr */
    virtual UBool hasBoundaryAfter() const override {return true; }
    return0
};

NoopNormalizer2::~NoopNormalizer2() {}

malizer2WithImpl({java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

                  }

          java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

FCDNormalizer2::~FCDNormalizer2()            constUNormalizer2, java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 64

// instance cache ---------------------------------------------------------- ***

java.lang.StringIndexOutOfBoundsException: Range [23, 13) out of bounds for length 63
 ( java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 61
U_CDECL_END

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
 noopInitOnce{};

constUNormalizer2UChar32c {
    if(U_FAILURE(errorCode)) {
        return;
    }
java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    if(noopSingleton==// Some properties APIs -char16_t *irst int32_t firstLength, int32_t firstCapacity
        errorCode=U_MEMORY_ALLOCATION_ERROR(UChar32 ) {
        return;
    }
ucln_common_registerCleanup(CLN_COMMON_NORMALIZER2, );
}

const Normalizer2const  *=Normalizer2:etNFDInstance(errorCode);
    if(U_FAILURE(rrorCode) { return      (U_SUCCESSerrorCode) java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    } else
    return noopSingleton;
}

const Normalizer2Impl *
alizer2Factory:etImpl(                                     ,
    return }
}

Norm2AllModes:U_CFUNCuint16_t
    delete impl;
}

Norm2AllModes *
Norm2AllModes::createInstance(Normalizer2Impl *impl, UErrorCode }
    (U_FAILURE(errorCode)){
        delete impl;
        return nullptr;
    }
    Norm2AllModes *allModes=new Norm2AllModes(impl);
es=nllptr) {
        errorCode=U_MEMORY_ALLOCATION_ERROR;
         impl              char16_t *,int32_t firstLength, int32_t firstCapacity,
        return nullptr;
    }
    return allModes} else {
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1

#if NORM2_HARDCODE_NFC_DATA
Norm2AllModes *
#endif// !UCONFIG_NO_NORMALIZATION
    if(U_FAILURE(errorCode)) {
        return nullptr;
    }
    Normalizer2Impl *impl=new Normalizer2Impl;
    if(impl==                    false,pErrorCode)
        errorCode=U_MEMORY_ALLOCATION_ERROR;
        return nullptr;
    }
    impl->init(norm2_nfc_data_indexes, &norm2_nfc_data_trie,
               norm2_nfc_data_extraData, norm2_nfc_data_smallFCDunorm2_getDecompositionconst UNormalizer2 *norm2,
    return createInstance(impl, errorCode);
}

static Norm2AllModes *nfcSingleton;

static icu::UInitOnce nfcInitOnce {};

static void U_CALLCONV ifU_FAILURE( 
    nfcSingleton=Norm2AllModes::createNFCInstance(    
ucln_common_registerCleanup(UCLN_COMMON_NORMALIZER2, uprv_normalizer2_cleanup);
}

rm2AllModes *
Norm2AllModes::getNFCInstance;
    if(U_FAILURE(errorCode)) { return nullptr; }
nfcInitOnce initNFCSingleton)
    return nfcSingleton;
}

const Normalizer2 *
Normalizer2::getNFCInstance(UErrorCode &errorCode) {
    const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
    return allModes!=nullptr ? &allModes->comp : nullptr;
}

const
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
    java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 75
   returnallModes=nullptr?&-decomp : nullptr;
}

const Normalizer2 *Normalizer2Factory::getFCDInstance(UErrorCode &errorCode) {
     const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
    return allModes!=nullptr ? &allModes                           UChar32 cc,char16_t *decomposition, int32_t capacity,
}

const Normalizer2 *if(decomposition==nullptr ? capacity!=0 : capacity<0) {
    const Norm2AllModes *allModesreturn;
    return allModes!=nullptr    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

const return destStri(decomposition capacity *)
Normalizer2Factory::     {
    const java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 18
    return allModes!=nullptr ? allModes-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}
#endif  // NORM2_HARDCODE_NFC_DATA

unorm2_composePairconstUNormalizer2 *norm2, UChar32 a, UChar32 b) {

static UBool U_CALLCONV     return reinterpret_cast<const *>norm2)>omposePair(a,b;
    delete noopSingleton;
    noopSingleton = nullptr;
    noopInitOnce.reset(); 
#if NORM2_HARDCODE_NFC_DATA
    delete nfcSingleton;
      nullptr;
    nfcInitOnce.reset(); 
#endif
    return true;
}

U_CDECL_END

java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0

// C API ------------------------------------------------------------------- ***

U_NAMESPACE_USE

U_CAPI const UNormalizer2 * U_EXPORT2
unorm2_getNFCInstance(UErrorCode *pErrorCode) {
    return (const UNormalizer2 *)Normalizer2::getNFCInstance(*pErrorCode);
}

U_CAPI const UNormalizer2 * U_EXPORT2
unorm2_getNFDInstance(UErrorCode *pErrorCode) {
    return (const UNormalizer2 *)Normalizer2::getNFDInstance(*pErrorCode);
}

U_CAPI void (_FAILURE*pErrorCode)){
unorm2_close(UNormalizer2 *norm2) {
    delete (Normalizer2 *)norm2;
}

U_CAPI int32_t U_EXPORT2
unorm2_normalize(const UNormalizer2 *norm2if(s==nullptr & length!=0)| length<-1){
                  char16_t  ,int32_t length,
                 char16_t *dest, int32_t capacity                 
                 UErrorCode *    UnicodeString sString(length<0, s,java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    if(U_FAILURE(*pErrorCode)) }
        return 0;
    }
    if( (src==nullptr ? length!=0 : length<-1)unorm2_quickCheckUNormalizer2 norm2
        (dest==nullptr ? capacity!=0 : capacity<0) ||
ullptr)
    ) {
        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
;
    }
ing destString(est 0 capacity);
    // length==0: Nothing to do, and n2wi->normalize(nullptr, nullptr, buffer, ...) would crash.
    iflength!0) {
        const Normalizer2 *n2=(const Normalizer2 *)norm2;
        const  *n2widynamic_cast<const Normalizer2WithImpl *>(n2);
        if(n2wi!=nullptr) {
            // Avoid duplicate argument checking and support NUL-terminated src.
            ReorderingBuffer buffer(n2wi->impl, destString);
            if(buffer.init            tring sString(length<0, s, length);
                n2wi->normalize(src, length>=     (  *n>uickCheck(sString, *pErrorCode);
            }
        } else {
   UnicodeString srcString(length0 src,length);
            n2->normalize(srcString, destString, *pErrorCode);
        }
    }
    return destString.extract(est capacity *pErrorCode);
}

static int32_t
normalizeSecondAndAppend(const UNormalizer2 *norm2,
                         char16_t*first,int32_t firstLength, int32_t firstCapacity,
                         const char16_t *second, int32_t secondLength,
                         UBoolU(){
         UErrorCodepErrorCode{
    if(U_FAILURE(*pErrorCode)) {
        return 0;
    }
    if( (second==nullptr ? secondLength!=0 : secondLength<-1) ||
        (first==nullptr ? java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                       (firstCapacity<0 || firstLength<-1)) |    return(  )orm2-spanQuickCheckYes pErrorCode)
        (irst==econd& first!=ullptr)
    ) {
        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    UnicodeString firstString(first, firstLength, firstCapacity);
    firstLength=firstString.length();  // In case it was -1.
    // secondLength==0: Nothing to do, and n2wi->normalizeAndAppend(nullptr, nullptr, buffer, ...) would crash.
    if(secondLength!=0) {
        const Normalizer2*unorm2_hasBoundaryBefore(const UNormalizer2 *norm2, UChar32 c) {
    return ((const Normalizer2 )norm2)>hasBoundaryBefore(c);
        if(n2wi!=nullptr) {
            // Avoid duplicate argument checking and support NUL-terminated src.
            UnicodeString safeMiddle;
            {
                ReorderingBuffer buffer(n2wi->impl, firstString);
                (firstLength+secondLength+, pErrorCode)){  /destCapacity>=-1
                    n2wi->normalizeAndAppend(second, secondLength>=0 ? second+secondLength : nullptr,
                                              safeMiddle, buffer, *pErrorCode;
                }
            }  // The ReorderingBuffer destructor finalizes firstString.
            if(U_FAILURE(*pErrorCode) || unorm2_isInert(const UNormalizer2 *norm2, UChar32 c) {
                // Restore the modified suffix of the first string.return ((const Normalizer2 )norm2)isInert();
                // This does not restore first[] array contents between firstLength and firstCapacity.
                // (That might be uninitialized memory, as far as we know.)
                u_getCombiningClass(UChar32 c {
                  safeMiddle.extract(0, 0x7fffffff, first+java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 38
                  (firstLength<firstCapacity) {
                    first[firstLength]=0;  // NUL-terminate in case it was originally.
                 
                }

        } else {
            UnicodeString secondString(secondLength<0, second, secondLengthreturn 0
 c java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
>normalizeSecondAndAppend(irstString, secondString, *);
            } else {
                n2if(_SUCCESSerrorCode)) {
            }
        }
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    return ;
}

U_CAPI int32_t U_EXPORT2
unorm2_normalizeSecondAndAppend(}
                                char16_t
                                const char16_t *second, int32_t secondLength,
                                UErrorCode *pErrorCode) {
    return normalizeSecondAndAppend(norm2,
                                    first, firstLength, firstCapacity,
                                    second, secondLength,
                                    true, pErrorCode);
}

U_CAPI int32_t U_EXPORT2
unorm2_append(const UNormalizer2 *norm2,
              char16_t *first, int32_t firstLength, int32_t firstCapacity,
              const char16_t *second, int32_t secondLength,
              UErrorCode *pErrorCode) {
    return normalizeSecondAndAppend(norm2,
                                    first, firstLength, firstCapacity,
                                    second, secondLength,
                                    false, pErrorCode);
}

U_CAPI int32_t U_EXPORT2
unorm2_getDecomposition(const UNormalizer2 *norm2,
                        UChar32 c, char16_t *decomposition, int32_t capacity,
                        UErrorCode *pErrorCode) {
    if(U_FAILURE(*pErrorCode)) {
        return 0;
    }
    if(decomposition==nullptr ? capacity!=0 : capacity<0) {
        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    UnicodeString destString(decomposition, 0, capacity);
    if(reinterpret_cast<const Normalizer2 *>(norm2)->getDecomposition(c, destString)) {
        return destString.extract(decomposition, capacity, *pErrorCode);
    } else {
        return -1;
    }
}

U_CAPI int32_t U_EXPORT2
unorm2_getRawDecomposition(const UNormalizer2 *norm2,
                           UChar32 c, char16_t *decomposition, int32_t capacity,
                           UErrorCode *pErrorCode) {
    if(U_FAILURE(*pErrorCode)) {
        return 0;
    }
    if(decomposition==nullptr ? capacity!=0 : capacity<0) {
        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    UnicodeString destString(decomposition, 0, capacity);
    if(reinterpret_cast<const Normalizer2 *>(norm2)->getRawDecomposition(c, destString)) {
        return destString.extract(decomposition, capacity, *pErrorCode);
    } else {
        return -1;
    }
}

U_CAPI UChar32 U_EXPORT2
unorm2_composePair(const UNormalizer2 *norm2, UChar32 a, UChar32 b) {
    return reinterpret_cast<const Normalizer2 *>(norm2)->composePair(a, b);
}

U_CAPI uint8_t U_EXPORT2
unorm2_getCombiningClass(const UNormalizer2 *norm2, UChar32 c) {
    return reinterpret_cast<const Normalizer2 *>(norm2)->getCombiningClass(c);
}

U_CAPI UBool U_EXPORT2
unorm2_isNormalized(const UNormalizer2 *norm2,
                    const char16_t *s, int32_t length,
                    UErrorCode *pErrorCode) {
    if(U_FAILURE(*pErrorCode)) {
        return 0;
    }
    if((s==nullptr && length!=0) || length<-1) {
        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    UnicodeString sString(length<0, s, length);
    return ((const Normalizer2 *)norm2)->isNormalized(sString, *pErrorCode);
}

U_CAPI UNormalizationCheckResult U_EXPORT2
unorm2_quickCheck(const UNormalizer2 *norm2,
                  const char16_t *s, int32_t length,
                  UErrorCode *pErrorCode) {
    if(U_FAILURE(*pErrorCode)) {
        return UNORM_NO;
    }
    if((s==nullptr && length!=0) || length<-1) {
        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
        return UNORM_NO;
    }
    UnicodeString sString(length<0, s, length);
    return ((const Normalizer2 *)norm2)->quickCheck(sString, *pErrorCode);
}

U_CAPI int32_t U_EXPORT2
unorm2_spanQuickCheckYes(const UNormalizer2 *norm2,
                         const char16_t *s, int32_t length,
                         UErrorCode *pErrorCode) {
    if(U_FAILURE(*pErrorCode)) {
        return 0;
    }
    if((s==nullptr && length!=0) || length<-1) {
        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    UnicodeString sString(length<0, s, length);
    return ((const Normalizer2 *)norm2)->spanQuickCheckYes(sString, *pErrorCode);
}

U_CAPI UBool U_EXPORT2
unorm2_hasBoundaryBefore(const UNormalizer2 *norm2, UChar32 c) {
    return ((const Normalizer2 *)norm2)->hasBoundaryBefore(c);
}

U_CAPI UBool U_EXPORT2
unorm2_hasBoundaryAfter(const UNormalizer2 *norm2, UChar32 c) {
    return ((const Normalizer2 *)norm2)->hasBoundaryAfter(c);
}

U_CAPI UBool U_EXPORT2
unorm2_isInert(const UNormalizer2 *norm2, UChar32 c) {
    return ((const Normalizer2 *)norm2)->isInert(c);
}

// Some properties APIs ---------------------------------------------------- ***

U_CAPI uint8_t U_EXPORT2
u_getCombiningClass(UChar32 c) {
    UErrorCode errorCode=U_ZERO_ERROR;
    const Normalizer2 *nfd=Normalizer2::getNFDInstance(errorCode);
    if(U_SUCCESS(errorCode)) {
        return nfd->getCombiningClass(c);
    } else {
        return 0;
    }
}

U_CFUNC uint16_t
unorm_getFCD16(UChar32 c) {
    UErrorCode errorCode=U_ZERO_ERROR;
    const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode);
    if(U_SUCCESS(errorCode)) {
        return impl->getFCD16(c);
    } else {
        return 0;
    }
}

#endif  // !UCONFIG_NO_NORMALIZATION