1 files changed, 278 insertions, 0 deletions
diff --git a/deps/icu-small/source/common/unorm.cpp b/deps/icu-small/source/common/unorm.cpp
new file mode 100644
index 0000000000..fb948b8805
--- /dev/null
+++ b/deps/icu-small/source/common/unorm.cpp
@@ -0,0 +1,278 @@
+/*
+******************************************************************************
+* 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 */