Source/WTF/icu/unicode/unorm.h - WebKit - Git at Google

 // © 2016 and later: Unicode, Inc. and others.
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 *******************************************************************************
 * Copyright (c) 1996-2016, International Business Machines Corporation
 *               and others. All Rights Reserved.
 *******************************************************************************
 * File unorm.h
 *
 * Created by: Vladimir Weinstein 12052000
 *
 * Modification history :
 *
 * Date        Name        Description
 * 02/01/01    synwee      Added normalization quickcheck enum and method.
 */
 #ifndef UNORM_H
 #define UNORM_H

 #include "unicode/utypes.h"

 #if !UCONFIG_NO_NORMALIZATION

 #include "unicode/uiter.h"
 #include "unicode/unorm2.h"

 /**
  * \file
  * \brief C API: Unicode Normalization
  *
  * Old Unicode normalization API.
  *
  * This API has been replaced by the unorm2.h API and is only available
  * for backward compatibility. The functions here simply delegate to the
  * unorm2.h functions, for example unorm2_getInstance() and unorm2_normalize().
  * There is one exception: The new API does not provide a replacement for unorm_compare().
  * Its declaration has been moved to unorm2.h.
  *
  * <code>unorm_normalize</code> transforms Unicode text into an equivalent composed or
  * decomposed form, allowing for easier sorting and searching of text.
  * <code>unorm_normalize</code> supports the standard normalization forms described in
  * <a href="http://www.unicode.org/unicode/reports/tr15/" target="unicode">
  * Unicode Standard Annex #15: Unicode Normalization Forms</a>.
  *
  * Characters with accents or other adornments can be encoded in
  * several different ways in Unicode.  For example, take the character A-acute.
  * In Unicode, this can be encoded as a single character (the
  * "composed" form):
  *
  * \code
  *      00C1    LATIN CAPITAL LETTER A WITH ACUTE
  * \endcode
  *
  * or as two separate characters (the "decomposed" form):
  *
  * \code
  *      0041    LATIN CAPITAL LETTER A
  *      0301    COMBINING ACUTE ACCENT
  * \endcode
  *
  * To a user of your program, however, both of these sequences should be
  * treated as the same "user-level" character "A with acute accent".  When you are searching or
  * comparing text, you must ensure that these two sequences are treated
  * equivalently.  In addition, you must handle characters with more than one
  * accent.  Sometimes the order of a character's combining accents is
  * significant, while in other cases accent sequences in different orders are
  * really equivalent.
  *
  * Similarly, the string "ffi" can be encoded as three separate letters:
  *
  * \code
  *      0066    LATIN SMALL LETTER F
  *      0066    LATIN SMALL LETTER F
  *      0069    LATIN SMALL LETTER I
  * \endcode
  *
  * or as the single character
  *
  * \code
  *      FB03    LATIN SMALL LIGATURE FFI
  * \endcode
  *
  * The ffi ligature is not a distinct semantic character, and strictly speaking
  * it shouldn't be in Unicode at all, but it was included for compatibility
  * with existing character sets that already provided it.  The Unicode standard
  * identifies such characters by giving them "compatibility" decompositions
  * into the corresponding semantic characters.  When sorting and searching, you
  * will often want to use these mappings.
  *
  * <code>unorm_normalize</code> helps solve these problems by transforming text into the
  * canonical composed and decomposed forms as shown in the first example above.
  * In addition, you can have it perform compatibility decompositions so that
  * you can treat compatibility characters the same as their equivalents.
  * Finally, <code>unorm_normalize</code> rearranges accents into the proper canonical
  * order, so that you do not have to worry about accent rearrangement on your
  * own.
  *
  * Form FCD, "Fast C or D", is also designed for collation.
  * It allows to work on strings that are not necessarily normalized
  * with an algorithm (like in collation) that works under "canonical closure", i.e., it treats precomposed
  * characters and their decomposed equivalents the same.
  *
  * It is not a normalization form because it does not provide for uniqueness of representation. Multiple strings
  * may be canonically equivalent (their NFDs are identical) and may all conform to FCD without being identical
  * themselves.
  *
  * The form is defined such that the "raw decomposition", the recursive canonical decomposition of each character,
  * results in a string that is canonically ordered. This means that precomposed characters are allowed for as long
  * as their decompositions do not need canonical reordering.
  *
  * Its advantage for a process like collation is that all NFD and most NFC texts - and many unnormalized texts -
  * already conform to FCD and do not need to be normalized (NFD) for such a process. The FCD quick check will
  * return UNORM_YES for most strings in practice.
  *
  * unorm_normalize(UNORM_FCD) may be implemented with UNORM_NFD.
  *
  * For more details on FCD see the collation design document:
  * http://source.icu-project.org/repos/icu/icuhtml/trunk/design/collation/ICU_collation_design.htm
  *
  * ICU collation performs either NFD or FCD normalization automatically if normalization
  * is turned on for the collator object.
  * Beyond collation and string search, normalized strings may be useful for string equivalence comparisons,
  * transliteration/transcription, unique representations, etc.
  *
  * The W3C generally recommends to exchange texts in NFC.
  * Note also that most legacy character encodings use only precomposed forms and often do not
  * encode any combining marks by themselves. For conversion to such character encodings the
  * Unicode text needs to be normalized to NFC.
  * For more usage examples, see the Unicode Standard Annex.
  */

 // Do not conditionalize the following enum with #ifndef U_HIDE_DEPRECATED_API,
 // it is needed for layout of Normalizer object.
 /**
  * Constants for normalization modes.
  * @deprecated ICU 56 Use unorm2.h instead.
  */
 typedef enum {
   /** No decomposition/composition. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_NONE = 1,
   /** Canonical decomposition. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_NFD = 2,
   /** Compatibility decomposition. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_NFKD = 3,
   /** Canonical decomposition followed by canonical composition. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_NFC = 4,
   /** Default normalization. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_DEFAULT = UNORM_NFC,
   /** Compatibility decomposition followed by canonical composition. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_NFKC =5,
   /** "Fast C or D" form. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_FCD = 6,

   /** One more than the highest normalization mode constant. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_MODE_COUNT
 } UNormalizationMode;

 #ifndef U_HIDE_DEPRECATED_API

 /**
  * Constants for options flags for normalization.
  * Use 0 for default options,
  * including normalization according to the Unicode version
  * that is currently supported by ICU (see u_getUnicodeVersion).
  * @deprecated ICU 56 Use unorm2.h instead.
  */
 enum {
     /**
      * Options bit set value to select Unicode 3.2 normalization
      * (except NormalizationCorrections).
      * At most one Unicode version can be selected at a time.
      * @deprecated ICU 56 Use unorm2.h instead.
      */
     UNORM_UNICODE_3_2=0x20
 };

 /**
  * Lowest-order bit number of unorm_compare() options bits corresponding to
  * normalization options bits.
  *
  * The options parameter for unorm_compare() uses most bits for
  * itself and for various comparison and folding flags.
  * The most significant bits, however, are shifted down and passed on
  * to the normalization implementation.
  * (That is, from unorm_compare(..., options, ...),
  * options>>UNORM_COMPARE_NORM_OPTIONS_SHIFT will be passed on to the
  * internal normalization functions.)
  *
  * @see unorm_compare
  * @deprecated ICU 56 Use unorm2.h instead.
  */
 #define UNORM_COMPARE_NORM_OPTIONS_SHIFT 20

 /**
  * Normalize a string.
  * The string will be normalized according the specified normalization mode
  * and options.
  * The source and result buffers must not be the same, nor overlap.
  *
  * @param source The string to normalize.
  * @param sourceLength The length of source, or -1 if NUL-terminated.
  * @param mode The normalization mode; one of UNORM_NONE,
  *             UNORM_NFD, UNORM_NFC, UNORM_NFKC, UNORM_NFKD, UNORM_DEFAULT.
  * @param options The normalization options, ORed together (0 for no options).
  * @param result A pointer to a buffer to receive the result string.
  *               The result string is NUL-terminated if possible.
  * @param resultLength The maximum size of result.
  * @param status A pointer to a UErrorCode to receive any errors.
  * @return The total buffer size needed; if greater than resultLength,
  *         the output was truncated, and the error code is set to U_BUFFER_OVERFLOW_ERROR.
  * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_DEPRECATED int32_t U_EXPORT2
 unorm_normalize(const UChar *source, int32_t sourceLength,
                 UNormalizationMode mode, int32_t options,
                 UChar *result, int32_t resultLength,
                 UErrorCode *status);

 /**
  * Performing quick check on a string, to quickly determine if the string is
  * in a particular normalization format.
  * Three types of result can be returned UNORM_YES, UNORM_NO or
  * UNORM_MAYBE. Result UNORM_YES indicates that the argument
  * string is in the desired normalized format, UNORM_NO determines that
  * argument string is not in the desired normalized format. A
  * UNORM_MAYBE result indicates that a more thorough check is required,
  * the user may have to put the string in its normalized form and compare the
  * results.
  *
  * @param source       string for determining if it is in a normalized format
  * @param sourcelength length of source to test, or -1 if NUL-terminated
  * @param mode         which normalization form to test for
  * @param status       a pointer to a UErrorCode to receive any errors
  * @return UNORM_YES, UNORM_NO or UNORM_MAYBE
  *
  * @see unorm_isNormalized
  * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_DEPRECATED UNormalizationCheckResult U_EXPORT2
 unorm_quickCheck(const UChar *source, int32_t sourcelength,
                  UNormalizationMode mode,
                  UErrorCode *status);

 /**
  * Performing quick check on a string; same as unorm_quickCheck but
  * takes an extra options parameter like most normalization functions.
  *
  * @param src        String that is to be tested if it is in a normalization format.
  * @param srcLength  Length of source to test, or -1 if NUL-terminated.
  * @param mode       Which normalization form to test for.
  * @param options    The normalization options, ORed together (0 for no options).
  * @param pErrorCode ICU error code in/out parameter.
  *                   Must fulfill U_SUCCESS before the function call.
  * @return UNORM_YES, UNORM_NO or UNORM_MAYBE
  *
  * @see unorm_quickCheck
  * @see unorm_isNormalized
  * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_DEPRECATED UNormalizationCheckResult U_EXPORT2
 unorm_quickCheckWithOptions(const UChar *src, int32_t srcLength,
                             UNormalizationMode mode, int32_t options,
                             UErrorCode *pErrorCode);

 /**
  * Test if a string is in a given normalization form.
  * This is semantically equivalent to source.equals(normalize(source, mode)) .
  *
  * Unlike unorm_quickCheck(), this function returns a definitive result,
  * never a "maybe".
  * For NFD, NFKD, and FCD, both functions work exactly the same.
  * For NFC and NFKC where quickCheck may return "maybe", this function will
  * perform further tests to arrive at a TRUE/FALSE result.
  *
  * @param src        String that is to be tested if it is in a normalization format.
  * @param srcLength  Length of source to test, or -1 if NUL-terminated.
  * @param mode       Which normalization form to test for.
  * @param pErrorCode ICU error code in/out parameter.
  *                   Must fulfill U_SUCCESS before the function call.
  * @return Boolean value indicating whether the source string is in the
  *         "mode" normalization form.
  *
  * @see unorm_quickCheck
  * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_DEPRECATED UBool U_EXPORT2
 unorm_isNormalized(const UChar *src, int32_t srcLength,
                    UNormalizationMode mode,
                    UErrorCode *pErrorCode);

 /**
  * Test if a string is in a given normalization form; same as unorm_isNormalized but
  * takes an extra options parameter like most normalization functions.
  *
  * @param src        String that is to be tested if it is in a normalization format.
  * @param srcLength  Length of source to test, or -1 if NUL-terminated.
  * @param mode       Which normalization form to test for.
  * @param options    The normalization options, ORed together (0 for no options).
  * @param pErrorCode ICU error code in/out parameter.
  *                   Must fulfill U_SUCCESS before the function call.
  * @return Boolean value indicating whether the source string is in the
  *         "mode/options" normalization form.
  *
  * @see unorm_quickCheck
  * @see unorm_isNormalized
  * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_DEPRECATED UBool U_EXPORT2
 unorm_isNormalizedWithOptions(const UChar *src, int32_t srcLength,
                               UNormalizationMode mode, int32_t options,
                               UErrorCode *pErrorCode);

 /**
  * Iterative normalization forward.
  * This function (together with unorm_previous) is somewhat
  * similar to the C++ Normalizer class (see its non-static functions).
  *
  * Iterative normalization is useful when only a small portion of a longer
  * string/text needs to be processed.
  *
  * For example, the likelihood may be high that processing the first 10% of some
  * text will be sufficient to find certain data.
  * Another example: When one wants to concatenate two normalized strings and get a
  * normalized result, it is much more efficient to normalize just a small part of
  * the result around the concatenation place instead of re-normalizing everything.
  *
  * The input text is an instance of the C character iteration API UCharIterator.
  * It may wrap around a simple string, a CharacterIterator, a Replaceable, or any
  * other kind of text object.
  *
  * If a buffer overflow occurs, then the caller needs to reset the iterator to the
  * old index and call the function again with a larger buffer - if the caller cares
  * for the actual output.
  * Regardless of the output buffer, the iterator will always be moved to the next
  * normalization boundary.
  *
  * This function (like unorm_previous) serves two purposes:
  *
  * 1) To find the next boundary so that the normalization of the part of the text
  * from the current position to that boundary does not affect and is not affected
  * by the part of the text beyond that boundary.
  *
  * 2) To normalize the text up to the boundary.
  *
  * The second step is optional, per the doNormalize parameter.
  * It is omitted for operations like string concatenation, where the two adjacent
  * string ends need to be normalized together.
  * In such a case, the output buffer will just contain a copy of the text up to the
  * boundary.
  *
  * pNeededToNormalize is an output-only parameter. Its output value is only defined
  * if normalization was requested (doNormalize) and successful (especially, no
  * buffer overflow).
  * It is useful for operations like a normalizing transliterator, where one would
  * not want to replace a piece of text if it is not modified.
  *
  * If doNormalize==TRUE and pNeededToNormalize!=NULL then *pNeeded... is set TRUE
  * if the normalization was necessary.
  *
  * If doNormalize==FALSE then *pNeededToNormalize will be set to FALSE.
  *
  * If the buffer overflows, then *pNeededToNormalize will be undefined;
  * essentially, whenever U_FAILURE is true (like in buffer overflows), this result
  * will be undefined.
  *
  * @param src The input text in the form of a C character iterator.
  * @param dest The output buffer; can be NULL if destCapacity==0 for pure preflighting.
  * @param destCapacity The number of UChars that fit into dest.
  * @param mode The normalization mode.
  * @param options The normalization options, ORed together (0 for no options).
  * @param doNormalize Indicates if the source text up to the next boundary
  *                    is to be normalized (TRUE) or just copied (FALSE).
  * @param pNeededToNormalize Output flag indicating if the normalization resulted in
  *                           different text from the input.
  *                           Not defined if an error occurs including buffer overflow.
  *                           Always FALSE if !doNormalize.
  * @param pErrorCode ICU error code in/out parameter.
  *                   Must fulfill U_SUCCESS before the function call.
  * @return Length of output (number of UChars) when successful or buffer overflow.
  *
  * @see unorm_previous
  * @see unorm_normalize
  *
  * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_DEPRECATED int32_t U_EXPORT2
 unorm_next(UCharIterator *src,
            UChar *dest, int32_t destCapacity,
            UNormalizationMode mode, int32_t options,
            UBool doNormalize, UBool *pNeededToNormalize,
            UErrorCode *pErrorCode);

 /**
  * Iterative normalization backward.
  * This function (together with unorm_next) is somewhat
  * similar to the C++ Normalizer class (see its non-static functions).
  * For all details see unorm_next.
  *
  * @param src The input text in the form of a C character iterator.
  * @param dest The output buffer; can be NULL if destCapacity==0 for pure preflighting.
  * @param destCapacity The number of UChars that fit into dest.
  * @param mode The normalization mode.
  * @param options The normalization options, ORed together (0 for no options).
  * @param doNormalize Indicates if the source text up to the next boundary
  *                    is to be normalized (TRUE) or just copied (FALSE).
  * @param pNeededToNormalize Output flag indicating if the normalization resulted in
  *                           different text from the input.
  *                           Not defined if an error occurs including buffer overflow.
  *                           Always FALSE if !doNormalize.
  * @param pErrorCode ICU error code in/out parameter.
  *                   Must fulfill U_SUCCESS before the function call.
  * @return Length of output (number of UChars) when successful or buffer overflow.
  *
  * @see unorm_next
  * @see unorm_normalize
  *
  * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_DEPRECATED int32_t U_EXPORT2
 unorm_previous(UCharIterator *src,
                UChar *dest, int32_t destCapacity,
                UNormalizationMode mode, int32_t options,
                UBool doNormalize, UBool *pNeededToNormalize,
                UErrorCode *pErrorCode);

 /**
  * Concatenate normalized strings, making sure that the result is normalized as well.
  *
  * If both the left and the right strings are in
  * the normalization form according to "mode/options",
  * then the result will be
  *
  * \code
  *     dest=normalize(left+right, mode, options)
  * \endcode
  *
  * With the input strings already being normalized,
  * this function will use unorm_next() and unorm_previous()
  * to find the adjacent end pieces of the input strings.
  * Only the concatenation of these end pieces will be normalized and
  * then concatenated with the remaining parts of the input strings.
  *
  * It is allowed to have dest==left to avoid copying the entire left string.
  *
  * @param left Left source string, may be same as dest.
  * @param leftLength Length of left source string, or -1 if NUL-terminated.
  * @param right Right source string. Must not be the same as dest, nor overlap.
  * @param rightLength Length of right source string, or -1 if NUL-terminated.
  * @param dest The output buffer; can be NULL if destCapacity==0 for pure preflighting.
  * @param destCapacity The number of UChars that fit into dest.
  * @param mode The normalization mode.
  * @param options The normalization options, ORed together (0 for no options).
  * @param pErrorCode ICU error code in/out parameter.
  *                   Must fulfill U_SUCCESS before the function call.
  * @return Length of output (number of UChars) when successful or buffer overflow.
  *
  * @see unorm_normalize
  * @see unorm_next
  * @see unorm_previous
  *
  * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_DEPRECATED 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);

 #endif  /* U_HIDE_DEPRECATED_API */
 #endif /* #if !UCONFIG_NO_NORMALIZATION */
 #endif
	// © 2016 and later: Unicode, Inc. and others.
	// License & terms of use: http://www.unicode.org/copyright.html
	/*
	*******************************************************************************
	* Copyright (c) 1996-2016, International Business Machines Corporation
	* and others. All Rights Reserved.
	*******************************************************************************
	* File unorm.h
	*
	* Created by: Vladimir Weinstein 12052000
	*
	* Modification history :
	*
	* Date Name Description
	* 02/01/01 synwee Added normalization quickcheck enum and method.
	*/
	#ifndef UNORM_H
	#define UNORM_H

	#include "unicode/utypes.h"

	#if !UCONFIG_NO_NORMALIZATION

	#include "unicode/uiter.h"
	#include "unicode/unorm2.h"

	/**
	* \file
	* \brief C API: Unicode Normalization
	*
	* Old Unicode normalization API.
	*
	* This API has been replaced by the unorm2.h API and is only available
	* for backward compatibility. The functions here simply delegate to the
	* unorm2.h functions, for example unorm2_getInstance() and unorm2_normalize().
	* There is one exception: The new API does not provide a replacement for unorm_compare().
	* Its declaration has been moved to unorm2.h.
	*
	* <code>unorm_normalize</code> transforms Unicode text into an equivalent composed or
	* decomposed form, allowing for easier sorting and searching of text.
	* <code>unorm_normalize</code> supports the standard normalization forms described in
	* <a href="http://www.unicode.org/unicode/reports/tr15/" target="unicode">
	* Unicode Standard Annex #15: Unicode Normalization Forms</a>.
	*
	* Characters with accents or other adornments can be encoded in
	* several different ways in Unicode. For example, take the character A-acute.
	* In Unicode, this can be encoded as a single character (the
	* "composed" form):
	*
	* \code
	* 00C1 LATIN CAPITAL LETTER A WITH ACUTE
	* \endcode
	*
	* or as two separate characters (the "decomposed" form):
	*
	* \code
	* 0041 LATIN CAPITAL LETTER A
	* 0301 COMBINING ACUTE ACCENT
	* \endcode
	*
	* To a user of your program, however, both of these sequences should be
	* treated as the same "user-level" character "A with acute accent". When you are searching or
	* comparing text, you must ensure that these two sequences are treated
	* equivalently. In addition, you must handle characters with more than one
	* accent. Sometimes the order of a character's combining accents is
	* significant, while in other cases accent sequences in different orders are
	* really equivalent.
	*
	* Similarly, the string "ffi" can be encoded as three separate letters:
	*
	* \code
	* 0066 LATIN SMALL LETTER F
	* 0066 LATIN SMALL LETTER F
	* 0069 LATIN SMALL LETTER I
	* \endcode
	*
	* or as the single character
	*
	* \code
	* FB03 LATIN SMALL LIGATURE FFI
	* \endcode
	*
	* The ffi ligature is not a distinct semantic character, and strictly speaking
	* it shouldn't be in Unicode at all, but it was included for compatibility
	* with existing character sets that already provided it. The Unicode standard
	* identifies such characters by giving them "compatibility" decompositions
	* into the corresponding semantic characters. When sorting and searching, you
	* will often want to use these mappings.
	*
	* <code>unorm_normalize</code> helps solve these problems by transforming text into the
	* canonical composed and decomposed forms as shown in the first example above.
	* In addition, you can have it perform compatibility decompositions so that
	* you can treat compatibility characters the same as their equivalents.
	* Finally, <code>unorm_normalize</code> rearranges accents into the proper canonical
	* order, so that you do not have to worry about accent rearrangement on your
	* own.
	*
	* Form FCD, "Fast C or D", is also designed for collation.
	* It allows to work on strings that are not necessarily normalized
	* with an algorithm (like in collation) that works under "canonical closure", i.e., it treats precomposed
	* characters and their decomposed equivalents the same.
	*
	* It is not a normalization form because it does not provide for uniqueness of representation. Multiple strings
	* may be canonically equivalent (their NFDs are identical) and may all conform to FCD without being identical
	* themselves.
	*
	* The form is defined such that the "raw decomposition", the recursive canonical decomposition of each character,
	* results in a string that is canonically ordered. This means that precomposed characters are allowed for as long
	* as their decompositions do not need canonical reordering.
	*
	* Its advantage for a process like collation is that all NFD and most NFC texts - and many unnormalized texts -
	* already conform to FCD and do not need to be normalized (NFD) for such a process. The FCD quick check will
	* return UNORM_YES for most strings in practice.
	*
	* unorm_normalize(UNORM_FCD) may be implemented with UNORM_NFD.
	*
	* For more details on FCD see the collation design document:
	* http://source.icu-project.org/repos/icu/icuhtml/trunk/design/collation/ICU_collation_design.htm
	*
	* ICU collation performs either NFD or FCD normalization automatically if normalization
	* is turned on for the collator object.
	* Beyond collation and string search, normalized strings may be useful for string equivalence comparisons,
	* transliteration/transcription, unique representations, etc.
	*
	* The W3C generally recommends to exchange texts in NFC.
	* Note also that most legacy character encodings use only precomposed forms and often do not
	* encode any combining marks by themselves. For conversion to such character encodings the
	* Unicode text needs to be normalized to NFC.
	* For more usage examples, see the Unicode Standard Annex.
	*/

	// Do not conditionalize the following enum with #ifndef U_HIDE_DEPRECATED_API,
	// it is needed for layout of Normalizer object.
	/**
	* Constants for normalization modes.
	* @deprecated ICU 56 Use unorm2.h instead.
	*/
	typedef enum {
	/** No decomposition/composition. @deprecated ICU 56 Use unorm2.h instead. */
	UNORM_NONE = 1,
	/** Canonical decomposition. @deprecated ICU 56 Use unorm2.h instead. */
	UNORM_NFD = 2,
	/** Compatibility decomposition. @deprecated ICU 56 Use unorm2.h instead. */
	UNORM_NFKD = 3,
	/** Canonical decomposition followed by canonical composition. @deprecated ICU 56 Use unorm2.h instead. */
	UNORM_NFC = 4,
	/** Default normalization. @deprecated ICU 56 Use unorm2.h instead. */
	UNORM_DEFAULT = UNORM_NFC,
	/** Compatibility decomposition followed by canonical composition. @deprecated ICU 56 Use unorm2.h instead. */
	UNORM_NFKC =5,
	/** "Fast C or D" form. @deprecated ICU 56 Use unorm2.h instead. */
	UNORM_FCD = 6,

	/** One more than the highest normalization mode constant. @deprecated ICU 56 Use unorm2.h instead. */
	UNORM_MODE_COUNT
	} UNormalizationMode;

	#ifndef U_HIDE_DEPRECATED_API

	/**
	* Constants for options flags for normalization.
	* Use 0 for default options,
	* including normalization according to the Unicode version
	* that is currently supported by ICU (see u_getUnicodeVersion).
	* @deprecated ICU 56 Use unorm2.h instead.
	*/
	enum {
	/**
	* Options bit set value to select Unicode 3.2 normalization
	* (except NormalizationCorrections).
	* At most one Unicode version can be selected at a time.
	* @deprecated ICU 56 Use unorm2.h instead.
	*/
	UNORM_UNICODE_3_2=0x20
	};

	/**
	* Lowest-order bit number of unorm_compare() options bits corresponding to
	* normalization options bits.
	*
	* The options parameter for unorm_compare() uses most bits for
	* itself and for various comparison and folding flags.
	* The most significant bits, however, are shifted down and passed on
	* to the normalization implementation.
	* (That is, from unorm_compare(..., options, ...),
	* options>>UNORM_COMPARE_NORM_OPTIONS_SHIFT will be passed on to the
	* internal normalization functions.)
	*
	* @see unorm_compare
	* @deprecated ICU 56 Use unorm2.h instead.
	*/
	#define UNORM_COMPARE_NORM_OPTIONS_SHIFT 20

	/**
	* Normalize a string.
	* The string will be normalized according the specified normalization mode
	* and options.
	* The source and result buffers must not be the same, nor overlap.
	*
	* @param source The string to normalize.
	* @param sourceLength The length of source, or -1 if NUL-terminated.
	* @param mode The normalization mode; one of UNORM_NONE,
	* UNORM_NFD, UNORM_NFC, UNORM_NFKC, UNORM_NFKD, UNORM_DEFAULT.
	* @param options The normalization options, ORed together (0 for no options).
	* @param result A pointer to a buffer to receive the result string.
	* The result string is NUL-terminated if possible.
	* @param resultLength The maximum size of result.
	* @param status A pointer to a UErrorCode to receive any errors.
	* @return The total buffer size needed; if greater than resultLength,
	* the output was truncated, and the error code is set to U_BUFFER_OVERFLOW_ERROR.
	* @deprecated ICU 56 Use unorm2.h instead.
	*/
	U_DEPRECATED int32_t U_EXPORT2
	unorm_normalize(const UChar *source, int32_t sourceLength,
	UNormalizationMode mode, int32_t options,
	UChar *result, int32_t resultLength,
	UErrorCode *status);

	/**
	* Performing quick check on a string, to quickly determine if the string is
	* in a particular normalization format.
	* Three types of result can be returned UNORM_YES, UNORM_NO or
	* UNORM_MAYBE. Result UNORM_YES indicates that the argument
	* string is in the desired normalized format, UNORM_NO determines that
	* argument string is not in the desired normalized format. A
	* UNORM_MAYBE result indicates that a more thorough check is required,
	* the user may have to put the string in its normalized form and compare the
	* results.
	*
	* @param source string for determining if it is in a normalized format
	* @param sourcelength length of source to test, or -1 if NUL-terminated
	* @param mode which normalization form to test for
	* @param status a pointer to a UErrorCode to receive any errors
	* @return UNORM_YES, UNORM_NO or UNORM_MAYBE
	*
	* @see unorm_isNormalized
	* @deprecated ICU 56 Use unorm2.h instead.
	*/
	U_DEPRECATED UNormalizationCheckResult U_EXPORT2
	unorm_quickCheck(const UChar *source, int32_t sourcelength,
	UNormalizationMode mode,
	UErrorCode *status);

	/**
	* Performing quick check on a string; same as unorm_quickCheck but
	* takes an extra options parameter like most normalization functions.
	*
	* @param src String that is to be tested if it is in a normalization format.
	* @param srcLength Length of source to test, or -1 if NUL-terminated.
	* @param mode Which normalization form to test for.
	* @param options The normalization options, ORed together (0 for no options).
	* @param pErrorCode ICU error code in/out parameter.
	* Must fulfill U_SUCCESS before the function call.
	* @return UNORM_YES, UNORM_NO or UNORM_MAYBE
	*
	* @see unorm_quickCheck
	* @see unorm_isNormalized
	* @deprecated ICU 56 Use unorm2.h instead.
	*/
	U_DEPRECATED UNormalizationCheckResult U_EXPORT2
	unorm_quickCheckWithOptions(const UChar *src, int32_t srcLength,
	UNormalizationMode mode, int32_t options,
	UErrorCode *pErrorCode);

	/**
	* Test if a string is in a given normalization form.
	* This is semantically equivalent to source.equals(normalize(source, mode)) .
	*
	* Unlike unorm_quickCheck(), this function returns a definitive result,
	* never a "maybe".
	* For NFD, NFKD, and FCD, both functions work exactly the same.
	* For NFC and NFKC where quickCheck may return "maybe", this function will
	* perform further tests to arrive at a TRUE/FALSE result.
	*
	* @param src String that is to be tested if it is in a normalization format.
	* @param srcLength Length of source to test, or -1 if NUL-terminated.
	* @param mode Which normalization form to test for.
	* @param pErrorCode ICU error code in/out parameter.
	* Must fulfill U_SUCCESS before the function call.
	* @return Boolean value indicating whether the source string is in the
	* "mode" normalization form.
	*
	* @see unorm_quickCheck
	* @deprecated ICU 56 Use unorm2.h instead.
	*/
	U_DEPRECATED UBool U_EXPORT2
	unorm_isNormalized(const UChar *src, int32_t srcLength,
	UNormalizationMode mode,
	UErrorCode *pErrorCode);

	/**
	* Test if a string is in a given normalization form; same as unorm_isNormalized but
	* takes an extra options parameter like most normalization functions.
	*
	* @param src String that is to be tested if it is in a normalization format.
	* @param srcLength Length of source to test, or -1 if NUL-terminated.
	* @param mode Which normalization form to test for.
	* @param options The normalization options, ORed together (0 for no options).
	* @param pErrorCode ICU error code in/out parameter.
	* Must fulfill U_SUCCESS before the function call.
	* @return Boolean value indicating whether the source string is in the
	* "mode/options" normalization form.
	*
	* @see unorm_quickCheck
	* @see unorm_isNormalized
	* @deprecated ICU 56 Use unorm2.h instead.
	*/
	U_DEPRECATED UBool U_EXPORT2
	unorm_isNormalizedWithOptions(const UChar *src, int32_t srcLength,
	UNormalizationMode mode, int32_t options,
	UErrorCode *pErrorCode);

	/**
	* Iterative normalization forward.
	* This function (together with unorm_previous) is somewhat
	* similar to the C++ Normalizer class (see its non-static functions).
	*
	* Iterative normalization is useful when only a small portion of a longer
	* string/text needs to be processed.
	*
	* For example, the likelihood may be high that processing the first 10% of some
	* text will be sufficient to find certain data.
	* Another example: When one wants to concatenate two normalized strings and get a
	* normalized result, it is much more efficient to normalize just a small part of
	* the result around the concatenation place instead of re-normalizing everything.
	*
	* The input text is an instance of the C character iteration API UCharIterator.
	* It may wrap around a simple string, a CharacterIterator, a Replaceable, or any
	* other kind of text object.
	*
	* If a buffer overflow occurs, then the caller needs to reset the iterator to the
	* old index and call the function again with a larger buffer - if the caller cares
	* for the actual output.
	* Regardless of the output buffer, the iterator will always be moved to the next
	* normalization boundary.
	*
	* This function (like unorm_previous) serves two purposes:
	*
	* 1) To find the next boundary so that the normalization of the part of the text
	* from the current position to that boundary does not affect and is not affected
	* by the part of the text beyond that boundary.
	*
	* 2) To normalize the text up to the boundary.
	*
	* The second step is optional, per the doNormalize parameter.
	* It is omitted for operations like string concatenation, where the two adjacent
	* string ends need to be normalized together.
	* In such a case, the output buffer will just contain a copy of the text up to the
	* boundary.
	*
	* pNeededToNormalize is an output-only parameter. Its output value is only defined
	* if normalization was requested (doNormalize) and successful (especially, no
	* buffer overflow).
	* It is useful for operations like a normalizing transliterator, where one would
	* not want to replace a piece of text if it is not modified.
	*
	* If doNormalize==TRUE and pNeededToNormalize!=NULL then *pNeeded... is set TRUE
	* if the normalization was necessary.
	*
	* If doNormalize==FALSE then *pNeededToNormalize will be set to FALSE.
	*
	* If the buffer overflows, then *pNeededToNormalize will be undefined;
	* essentially, whenever U_FAILURE is true (like in buffer overflows), this result
	* will be undefined.
	*
	* @param src The input text in the form of a C character iterator.
	* @param dest The output buffer; can be NULL if destCapacity==0 for pure preflighting.
	* @param destCapacity The number of UChars that fit into dest.
	* @param mode The normalization mode.
	* @param options The normalization options, ORed together (0 for no options).
	* @param doNormalize Indicates if the source text up to the next boundary
	* is to be normalized (TRUE) or just copied (FALSE).
	* @param pNeededToNormalize Output flag indicating if the normalization resulted in
	* different text from the input.
	* Not defined if an error occurs including buffer overflow.
	* Always FALSE if !doNormalize.
	* @param pErrorCode ICU error code in/out parameter.
	* Must fulfill U_SUCCESS before the function call.
	* @return Length of output (number of UChars) when successful or buffer overflow.
	*
	* @see unorm_previous
	* @see unorm_normalize
	*
	* @deprecated ICU 56 Use unorm2.h instead.
	*/
	U_DEPRECATED int32_t U_EXPORT2
	unorm_next(UCharIterator *src,
	UChar *dest, int32_t destCapacity,
	UNormalizationMode mode, int32_t options,
	UBool doNormalize, UBool *pNeededToNormalize,
	UErrorCode *pErrorCode);

	/**
	* Iterative normalization backward.
	* This function (together with unorm_next) is somewhat
	* similar to the C++ Normalizer class (see its non-static functions).
	* For all details see unorm_next.
	*
	* @param src The input text in the form of a C character iterator.
	* @param dest The output buffer; can be NULL if destCapacity==0 for pure preflighting.
	* @param destCapacity The number of UChars that fit into dest.
	* @param mode The normalization mode.
	* @param options The normalization options, ORed together (0 for no options).
	* @param doNormalize Indicates if the source text up to the next boundary
	* is to be normalized (TRUE) or just copied (FALSE).
	* @param pNeededToNormalize Output flag indicating if the normalization resulted in
	* different text from the input.
	* Not defined if an error occurs including buffer overflow.
	* Always FALSE if !doNormalize.
	* @param pErrorCode ICU error code in/out parameter.
	* Must fulfill U_SUCCESS before the function call.
	* @return Length of output (number of UChars) when successful or buffer overflow.
	*
	* @see unorm_next
	* @see unorm_normalize
	*
	* @deprecated ICU 56 Use unorm2.h instead.
	*/
	U_DEPRECATED int32_t U_EXPORT2
	unorm_previous(UCharIterator *src,
	UChar *dest, int32_t destCapacity,
	UNormalizationMode mode, int32_t options,
	UBool doNormalize, UBool *pNeededToNormalize,
	UErrorCode *pErrorCode);

	/**
	* Concatenate normalized strings, making sure that the result is normalized as well.
	*
	* If both the left and the right strings are in
	* the normalization form according to "mode/options",
	* then the result will be
	*
	* \code
	* dest=normalize(left+right, mode, options)
	* \endcode
	*
	* With the input strings already being normalized,
	* this function will use unorm_next() and unorm_previous()
	* to find the adjacent end pieces of the input strings.
	* Only the concatenation of these end pieces will be normalized and
	* then concatenated with the remaining parts of the input strings.
	*
	* It is allowed to have dest==left to avoid copying the entire left string.
	*
	* @param left Left source string, may be same as dest.
	* @param leftLength Length of left source string, or -1 if NUL-terminated.
	* @param right Right source string. Must not be the same as dest, nor overlap.
	* @param rightLength Length of right source string, or -1 if NUL-terminated.
	* @param dest The output buffer; can be NULL if destCapacity==0 for pure preflighting.
	* @param destCapacity The number of UChars that fit into dest.
	* @param mode The normalization mode.
	* @param options The normalization options, ORed together (0 for no options).
	* @param pErrorCode ICU error code in/out parameter.
	* Must fulfill U_SUCCESS before the function call.
	* @return Length of output (number of UChars) when successful or buffer overflow.
	*
	* @see unorm_normalize
	* @see unorm_next
	* @see unorm_previous
	*
	* @deprecated ICU 56 Use unorm2.h instead.
	*/
	U_DEPRECATED 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);

	#endif /* U_HIDE_DEPRECATED_API */
	#endif /* #if !UCONFIG_NO_NORMALIZATION */
	#endif