#define uninorm_is_composing(nf) \
((* (const unsigned int *) (nf) >> 1) & 1)
+/* Return the decomposing variant of a normalization form.
+ This maps NFC,NFD -> NFD and NFKC,NFKD -> NFKD. */
+extern uninorm_t uninorm_decomposing_form (uninorm_t nf);
+
/* Return the specified normalization form of a string. */
extern uint8_t *
uint32_t *resultbuf, size_t *lengthp);
+/* Compare S1 and S2, ignoring differences in normalization.
+ NF must be either UNINORM_NFD or UNINORM_NFKD.
+ If successful, set *RESULTP to -1 if S1 < S2, 0 if S1 = S2, 1 if S1 > S2, and
+ return 0. Upon failure, return -1 with errno set. */
+extern int
+ u8_normcmp (const uint8_t *s1, size_t n1, const uint8_t *s2, size_t n2,
+ uninorm_t nf, int *resultp);
+extern int
+ u16_normcmp (const uint16_t *s1, size_t n1, const uint16_t *s2, size_t n2,
+ uninorm_t nf, int *resultp);
+extern int
+ u32_normcmp (const uint32_t *s1, size_t n1, const uint32_t *s2, size_t n2,
+ uninorm_t nf, int *resultp);
+
+
+/* Converts the string S of length N to a string in locale encoding, in such a
+ way that comparing uN_normxfrm (S1) and uN_normxfrm (S2) with memcmp2() is
+ equivalent to comparing S1 and S2 with uN_normcoll().
+ NF must be either UNINORM_NFC or UNINORM_NFKC. */
+extern char *
+ u8_normxfrm (const uint8_t *s, size_t n, uninorm_t nf,
+ char *resultbuf, size_t *lengthp);
+extern char *
+ u16_normxfrm (const uint16_t *s, size_t n, uninorm_t nf,
+ char *resultbuf, size_t *lengthp);
+extern char *
+ u32_normxfrm (const uint32_t *s, size_t n, uninorm_t nf,
+ char *resultbuf, size_t *lengthp);
+
+
+/* Compare S1 and S2, ignoring differences in normalization, using the
+ collation rules of the current locale.
+ NF must be either UNINORM_NFC or UNINORM_NFKC.
+ If successful, set *RESULTP to -1 if S1 < S2, 0 if S1 = S2, 1 if S1 > S2, and
+ return 0. Upon failure, return -1 with errno set. */
+extern int
+ u8_normcoll (const uint8_t *s1, size_t n1, const uint8_t *s2, size_t n2,
+ uninorm_t nf, int *resultp);
+extern int
+ u16_normcoll (const uint16_t *s1, size_t n1, const uint16_t *s2, size_t n2,
+ uninorm_t nf, int *resultp);
+extern int
+ u32_normcoll (const uint32_t *s1, size_t n1, const uint32_t *s2, size_t n2,
+ uninorm_t nf, int *resultp);
+
+
+/* Normalization of a stream of Unicode characters.
+
+ A "stream of Unicode characters" is essentially a function that accepts an
+ ucs4_t argument repeatedly, optionally combined with a function that
+ "flushes" the stream. */
+
+/* Data type of a stream of Unicode characters that normalizes its input
+ according to a given normalization form and passes the normalized character
+ sequence to the encapsulated stream of Unicode characters. */
+struct uninorm_filter;
+
+/* Create and return a normalization filter for Unicode characters.
+ The pair (stream_func, stream_data) is the encapsulated stream.
+ stream_func (stream_data, uc) receives the Unicode character uc
+ and returns 0 if successful, or -1 with errno set upon failure.
+ Return the new filter, or NULL with errno set upon failure. */
+extern struct uninorm_filter *
+ uninorm_filter_create (uninorm_t nf,
+ int (*stream_func) (void *stream_data, ucs4_t uc),
+ void *stream_data);
+
+/* Stuff a Unicode character into a normalizing filter.
+ Return 0 if successful, or -1 with errno set upon failure. */
+extern int
+ uninorm_filter_write (struct uninorm_filter *filter, ucs4_t uc);
+
+/* Bring data buffered in the filter to its destination, the encapsulated
+ stream.
+ Return 0 if successful, or -1 with errno set upon failure.
+ Note! If after calling this function, additional characters are written
+ into the filter, the resulting character sequence in the encapsulated stream
+ will not necessarily be normalized. */
+extern int
+ uninorm_filter_flush (struct uninorm_filter *filter);
+
+/* Bring data buffered in the filter to its destination, the encapsulated
+ stream, then close and free the filter.
+ Return 0 if successful, or -1 with errno set upon failure. */
+extern int
+ uninorm_filter_free (struct uninorm_filter *filter);
+
+
#ifdef __cplusplus
}
#endif