// © 2016 and later: Unicode, Inc. and others.

// License & terms of use: http://www.unicode.org/copyright.html

/*

******************************************************************************

* Copyright (c) 1996-2014, International Business Machines

* Corporation and others. All Rights Reserved.

******************************************************************************

* File unorm.cpp

*

* Created by: Vladimir Weinstein 12052000

*

* Modification history :

*

* Date        Name        Description

* 02/01/01    synwee      Added normalization quickcheck enum and method.

* 02/12/01    synwee      Commented out quickcheck util api has been approved

*                         Added private method for doing FCD checks

* 02/23/01    synwee      Modified quickcheck and checkFCE to run through 

*                         string for codepoints < 0x300 for the normalization 

*                         mode NFC.

* 05/25/01+   Markus Scherer total rewrite, implement all normalization here

*                         instead of just wrappers around normlzr.cpp,

*                         load unorm.dat, support Unicode 3.1 with

*                         supplementary code points, etc.

* 2009-nov..2010-jan  Markus Scherer  total rewrite, new Normalizer2 API & code

*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_NORMALIZATION

#include "unicode/udata.h"

#include "unicode/ustring.h"

#include "unicode/uiter.h"

#include "unicode/unorm.h"

#include "unicode/unorm2.h"

#include "normalizer2impl.h"

#include "unormimp.h"

#include "uprops.h"

#include "ustr_imp.h"

U_NAMESPACE_USE

/* quick check functions ---------------------------------------------------- */

U_CAPI UNormalizationCheckResult U_EXPORT2

unorm_quickCheck(const UChar *src,

                 int32_t srcLength, 

                 UNormalizationMode mode,

                 UErrorCode *pErrorCode) {

    const Normalizer2 *n2=Normalizer2Factory::getInstance(mode, *pErrorCode);

    return unorm2_quickCheck((const UNormalizer2 *)n2, src, srcLength, pErrorCode);

}

U_CAPI UNormalizationCheckResult U_EXPORT2

unorm_quickCheckWithOptions(const UChar *src, int32_t srcLength, 

                            UNormalizationMode mode, int32_t options,

                            UErrorCode *pErrorCode) {

    const Normalizer2 *n2=Normalizer2Factory::getInstance(mode, *pErrorCode);

    if(options&UNORM_UNICODE_3_2) {

        FilteredNormalizer2 fn2(*n2, *uniset_getUnicode32Instance(*pErrorCode));

        return unorm2_quickCheck(

            reinterpret_cast<const UNormalizer2 *>(static_cast<Normalizer2 *>(&fn2)),

            src, srcLength, pErrorCode);

    } else {

        return unorm2_quickCheck((const UNormalizer2 *)n2, src, srcLength, pErrorCode);

    }

}

U_CAPI UBool U_EXPORT2

unorm_isNormalized(const UChar *src, int32_t srcLength,

                   UNormalizationMode mode,

                   UErrorCode *pErrorCode) {

    const Normalizer2 *n2=Normalizer2Factory::getInstance(mode, *pErrorCode);

    return unorm2_isNormalized((const UNormalizer2 *)n2, src, srcLength, pErrorCode);

}

U_CAPI UBool U_EXPORT2

unorm_isNormalizedWithOptions(const UChar *src, int32_t srcLength,

                              UNormalizationMode mode, int32_t options,

                              UErrorCode *pErrorCode) {

    const Normalizer2 *n2=Normalizer2Factory::getInstance(mode, *pErrorCode);

    if(options&UNORM_UNICODE_3_2) {

        FilteredNormalizer2 fn2(*n2, *uniset_getUnicode32Instance(*pErrorCode));

        return unorm2_isNormalized(

            reinterpret_cast<const UNormalizer2 *>(static_cast<Normalizer2 *>(&fn2)),

            src, srcLength, pErrorCode);

    } else {

        return unorm2_isNormalized((const UNormalizer2 *)n2, src, srcLength, pErrorCode);

    }

}

/* normalize() API ---------------------------------------------------------- */

/** Public API for normalizing. */

U_CAPI int32_t U_EXPORT2

unorm_normalize(const UChar *src, int32_t srcLength,

                UNormalizationMode mode, int32_t options,

                UChar *dest, int32_t destCapacity,

                UErrorCode *pErrorCode) {

    const Normalizer2 *n2=Normalizer2Factory::getInstance(mode, *pErrorCode);

    if(options&UNORM_UNICODE_3_2) {

        FilteredNormalizer2 fn2(*n2, *uniset_getUnicode32Instance(*pErrorCode));

        return unorm2_normalize(

            reinterpret_cast<const UNormalizer2 *>(static_cast<Normalizer2 *>(&fn2)),

            src, srcLength, dest, destCapacity, pErrorCode);

    } else {

        return unorm2_normalize((const UNormalizer2 *)n2,

            src, srcLength, dest, destCapacity, pErrorCode);

    }

}

/* iteration functions ------------------------------------------------------ */

static int32_t

_iterate(UCharIterator *src, UBool forward,

              UChar *dest, int32_t destCapacity,

              const Normalizer2 *n2,

              UBool doNormalize, UBool *pNeededToNormalize,

              UErrorCode *pErrorCode) {

    if(U_FAILURE(*pErrorCode)) {

        return 0;

    }

    if(destCapacity<0 || (dest==NULL && destCapacity>0) || src==NULL) {

        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;

        return 0;

    }

    if(pNeededToNormalize!=NULL) {

        *pNeededToNormalize=FALSE;

    }

    if(!(forward ? src->hasNext(src) : src->hasPrevious(src))) {

        return u_terminateUChars(dest, destCapacity, 0, pErrorCode);

    }

    UnicodeString buffer;

    UChar32 c;

    if(forward) {

        /* get one character and ignore its properties */

        buffer.append(uiter_next32(src));

        /* get all following characters until we see a boundary */

        while((c=uiter_next32(src))>=0) {

            if(n2->hasBoundaryBefore(c)) {

                /* back out the latest movement to stop at the boundary */

                src->move(src, -U16_LENGTH(c), UITER_CURRENT);

                break;

            } else {

                buffer.append(c);

            }

        }

    } else {

        while((c=uiter_previous32(src))>=0) {

            /* always write this character to the front of the buffer */

            buffer.insert(0, c);

            /* stop if this just-copied character is a boundary */

            if(n2->hasBoundaryBefore(c)) {

                break;

            }

        }

    }

    UnicodeString destString(dest, 0, destCapacity);

    if(buffer.length()>0 && doNormalize) {

        n2->normalize(buffer, destString, *pErrorCode).extract(dest, destCapacity, *pErrorCode);

        if(pNeededToNormalize!=NULL && U_SUCCESS(*pErrorCode)) {

            *pNeededToNormalize= destString!=buffer;

        }

        return destString.length();

    } else {

        /* just copy the source characters */

        return buffer.extract(dest, destCapacity, *pErrorCode);

    }

}

static int32_t

unorm_iterate(UCharIterator *src, UBool forward,

              UChar *dest, int32_t destCapacity,

              UNormalizationMode mode, int32_t options,

              UBool doNormalize, UBool *pNeededToNormalize,

              UErrorCode *pErrorCode) {

    const Normalizer2 *n2=Normalizer2Factory::getInstance(mode, *pErrorCode);

    if(options&UNORM_UNICODE_3_2) {

        const UnicodeSet *uni32 = uniset_getUnicode32Instance(*pErrorCode);

        if(U_FAILURE(*pErrorCode)) {

            return 0;

        }

        FilteredNormalizer2 fn2(*n2, *uni32);

        return _iterate(src, forward, dest, destCapacity,

            &fn2, doNormalize, pNeededToNormalize, pErrorCode);

    }

    return _iterate(src, forward, dest, destCapacity,

            n2, doNormalize, pNeededToNormalize, pErrorCode);

}

U_CAPI int32_t U_EXPORT2

unorm_previous(UCharIterator *src,

               UChar *dest, int32_t destCapacity,

               UNormalizationMode mode, int32_t options,

               UBool doNormalize, UBool *pNeededToNormalize,

               UErrorCode *pErrorCode) {

    return unorm_iterate(src, FALSE,

                         dest, destCapacity,

                         mode, options,

                         doNormalize, pNeededToNormalize,

                         pErrorCode);

}

U_CAPI int32_t U_EXPORT2

unorm_next(UCharIterator *src,

           UChar *dest, int32_t destCapacity,

           UNormalizationMode mode, int32_t options,

           UBool doNormalize, UBool *pNeededToNormalize,

           UErrorCode *pErrorCode) {

    return unorm_iterate(src, TRUE,

                         dest, destCapacity,

                         mode, options,

                         doNormalize, pNeededToNormalize,

                         pErrorCode);

}

/* Concatenation of normalized strings -------------------------------------- */

static int32_t

_concatenate(const UChar *left, int32_t leftLength,

                  const UChar *right, int32_t rightLength,

                  UChar *dest, int32_t destCapacity,

                  const Normalizer2 *n2,

                  UErrorCode *pErrorCode) {

    if(U_FAILURE(*pErrorCode)) {

        return 0;

    }

    if(destCapacity<0 || (dest==NULL && destCapacity>0) ||

        left==NULL || leftLength<-1 || right==NULL || rightLength<-1) {

        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;

        return 0;

    }

    /* check for overlapping right and destination */

    if( dest!=NULL &&

        ((right>=dest && right<(dest+destCapacity)) ||

         (rightLength>0 && dest>=right && dest<(right+rightLength)))

    ) {

        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;

        return 0;

    }

    /* allow left==dest */

    UnicodeString destString;

    if(left==dest) {

        destString.setTo(dest, leftLength, destCapacity);

    } else {

        destString.setTo(dest, 0, destCapacity);

        destString.append(left, leftLength);

    }

    return n2->append(destString, UnicodeString(rightLength<0, right, rightLength), *pErrorCode).

           extract(dest, destCapacity, *pErrorCode);

}

U_CAPI int32_t U_EXPORT2

unorm_concatenate(const UChar *left, int32_t leftLength,

                  const UChar *right, int32_t rightLength,

                  UChar *dest, int32_t destCapacity,

                  UNormalizationMode mode, int32_t options,

                  UErrorCode *pErrorCode) {

    const Normalizer2 *n2=Normalizer2Factory::getInstance(mode, *pErrorCode);

    if(options&UNORM_UNICODE_3_2) {

        const UnicodeSet *uni32 = uniset_getUnicode32Instance(*pErrorCode);

        if(U_FAILURE(*pErrorCode)) {

            return 0;

        }

        FilteredNormalizer2 fn2(*n2, *uni32);

        return _concatenate(left, leftLength, right, rightLength,

            dest, destCapacity, &fn2, pErrorCode);

    }

    return _concatenate(left, leftLength, right, rightLength,

        dest, destCapacity, n2, pErrorCode);

}

#endif /* #if !UCONFIG_NO_NORMALIZATION */