ICU 56 update step 1

source/common/unicode/unorm.h

 /*
 *******************************************************************************
-* Copyright (c) 1996-2010, International Business Machines Corporation
+* Copyright (c) 1996-2015, 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"
 
+#ifndef U_HIDE_DEPRECATED_API
+
 /**
  * \file
  * \brief C API: Unicode Normalization 
  *
- * <h2>Unicode normalization API</h2>
+ * Old Unicode normalization API.
  *
- * Note: This API has been replaced by the unorm2.h API and is only available
+ * 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
@@ skipping 74 matching lines @@
  * 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.
  */
 
+#ifndef U_HIDE_DEPRECATED_API
 /**
  * Constants for normalization modes.
- * @stable ICU 2.0
+ * @deprecated ICU 56 Use unorm2.h instead.
  */
 typedef enum {
-  /** No decomposition/composition. @stable ICU 2.0 */
+  /** No decomposition/composition. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_NONE = 1, 
-  /** Canonical decomposition. @stable ICU 2.0 */
+  /** Canonical decomposition. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_NFD = 2,
-  /** Compatibility decomposition. @stable ICU 2.0 */
+  /** Compatibility decomposition. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_NFKD = 3,
-  /** Canonical decomposition followed by canonical composition. @stable ICU 2.0 */
+  /** Canonical decomposition followed by canonical composition. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_NFC = 4,
-  /** Default normalization. @stable ICU 2.0 */
+  /** Default normalization. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_DEFAULT = UNORM_NFC, 
-  /** Compatibility decomposition followed by canonical composition. @stable ICU 2.0 */
+  /** Compatibility decomposition followed by canonical composition. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_NFKC =5,
-  /** "Fast C or D" form. @stable ICU 2.0 */
+  /** "Fast C or D" form. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_FCD = 6,
 
-  /** One more than the highest normalization mode constant. @stable ICU 2.0 */
+  /** One more than the highest normalization mode constant. @deprecated ICU 56 Use unorm2.h instead. */
   UNORM_MODE_COUNT
 } UNormalizationMode;
+#endif  /* 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).
- * @stable ICU 2.6
+ * @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.
-     * @stable ICU 2.6
+     * @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
- * @stable ICU 2.6
+ * @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.
- * @stable ICU 2.0
+ * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_STABLE 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
- * @stable ICU 2.0
+ * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_STABLE 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
- * @stable ICU 2.6
+ * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_STABLE 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
- * @stable ICU 2.2
+ * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_STABLE 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
- * @stable ICU 2.6
+ * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_STABLE 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).
@@ skipping 57 matching lines @@
  *                           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
  *
- * @stable ICU 2.1
+ * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_STABLE 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.
@@ skipping 12 matching lines @@
  *                           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
  *
- * @stable ICU 2.1
+ * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_STABLE 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.
@@ skipping 23 matching lines @@
  * @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
  *
- * @stable ICU 2.1
+ * @deprecated ICU 56 Use unorm2.h instead.
  */
 U_STABLE 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);
 
-/**
- * Option bit for unorm_compare:
- * Both input strings are assumed to fulfill FCD conditions.
- * @stable ICU 2.2
- */
-#define UNORM_INPUT_IS_FCD          0x20000
-
-/**
- * Option bit for unorm_compare:
- * Perform case-insensitive comparison.
- * @stable ICU 2.2
- */
-#define U_COMPARE_IGNORE_CASE       0x10000
-
-#ifndef U_COMPARE_CODE_POINT_ORDER
-/* see also unistr.h and ustring.h */
-/**
- * Option bit for u_strCaseCompare, u_strcasecmp, unorm_compare, etc:
- * Compare strings in code point order instead of code unit order.
- * @stable ICU 2.2
- */
-#define U_COMPARE_CODE_POINT_ORDER  0x8000
+#endif  /* U_HIDE_DEPRECATED_API */
+#endif /* #if !UCONFIG_NO_NORMALIZATION */
 #endif
-
-/**
- * Compare two strings for canonical equivalence.
- * Further options include case-insensitive comparison and
- * code point order (as opposed to code unit order).
- *
- * Canonical equivalence between two strings is defined as their normalized
- * forms (NFD or NFC) being identical.
- * This function compares strings incrementally instead of normalizing
- * (and optionally case-folding) both strings entirely,
- * improving performance significantly.
- *
- * Bulk normalization is only necessary if the strings do not fulfill the FCD
- * conditions. Only in this case, and only if the strings are relatively long,
- * is memory allocated temporarily.
- * For FCD strings and short non-FCD strings there is no memory allocation.
- *
- * Semantically, this is equivalent to
- *   strcmp[CodePointOrder](NFD(foldCase(NFD(s1))), NFD(foldCase(NFD(s2))))
- * where code point order and foldCase are all optional.
- *
- * UAX 21 2.5 Caseless Matching specifies that for a canonical caseless match
- * the case folding must be performed first, then the normalization.
- *
- * @param s1 First source string.
- * @param length1 Length of first source string, or -1 if NUL-terminated.
- *
- * @param s2 Second source string.
- * @param length2 Length of second source string, or -1 if NUL-terminated.
- *
- * @param options A bit set of options:
- *   - U_FOLD_CASE_DEFAULT or 0 is used for default options:
- *     Case-sensitive comparison in code unit order, and the input strings
- *     are quick-checked for FCD.
- *
- *   - UNORM_INPUT_IS_FCD
- *     Set if the caller knows that both s1 and s2 fulfill the FCD conditions.
- *     If not set, the function will quickCheck for FCD
- *     and normalize if necessary.
- *
- *   - U_COMPARE_CODE_POINT_ORDER
- *     Set to choose code point order instead of code unit order
- *     (see u_strCompare for details).
- *
- *   - U_COMPARE_IGNORE_CASE
- *     Set to compare strings case-insensitively using case folding,
- *     instead of case-sensitively.
- *     If set, then the following case folding options are used.
- *
- *   - Options as used with case-insensitive comparisons, currently:
- *
- *   - U_FOLD_CASE_EXCLUDE_SPECIAL_I
- *    (see u_strCaseCompare for details)
- *
- *   - regular normalization options shifted left by UNORM_COMPARE_NORM_OPTIONS_SHIFT
- *
- * @param pErrorCode ICU error code in/out parameter.
- *                   Must fulfill U_SUCCESS before the function call.
- * @return <0 or 0 or >0 as usual for string comparisons
- *
- * @see unorm_normalize
- * @see UNORM_FCD
- * @see u_strCompare
- * @see u_strCaseCompare
- *
- * @stable ICU 2.2
- */
-U_STABLE int32_t U_EXPORT2
-unorm_compare(const UChar *s1, int32_t length1,
-              const UChar *s2, int32_t length2,
-              uint32_t options,
-              UErrorCode *pErrorCode);
-
-#endif /* #if !UCONFIG_NO_NORMALIZATION */
-
-#endif