summaryrefslogtreecommitdiff
path: root/doc/unicase.texi
diff options
context:
space:
mode:
Diffstat (limited to 'doc/unicase.texi')
-rw-r--r--doc/unicase.texi364
1 files changed, 364 insertions, 0 deletions
diff --git a/doc/unicase.texi b/doc/unicase.texi
new file mode 100644
index 00000000..14b46be0
--- /dev/null
+++ b/doc/unicase.texi
@@ -0,0 +1,364 @@
+@node unicase.h
+@chapter Case mappings @code{<unicase.h>}
+
+This include file defines functions for case mapping for Unicode strings and
+case insensitive comparison of Unicode strings and C strings.
+
+These string functions fix the problems that were mentioned in
+@ref{char * strings}, namely, they handle the Croatian
+@sc{LETTER DZ WITH CARON}, the German @sc{LATIN SMALL LETTER SHARP S}, the
+Greek sigma and the Lithuanian i correctly.
+
+@menu
+* Case mappings of characters::
+* Case mappings of strings::
+* Case mappings of substrings::
+* Case insensitive comparison::
+* Case detection::
+@end menu
+
+@node Case mappings of characters
+@section Case mappings of characters
+
+@cindex Unicode character, case mappings
+The following functions implement case mappings on Unicode characters ---
+for those cases only where the result of the mapping is a again a single
+Unicode character.
+
+These mappings are locale and context independent.
+
+@cartouche
+@strong{WARNING!} These functions are not sufficient for languages such as
+German, Greek and Lithuanian. Better use the functions below that treat an
+entire string at once and are language aware.
+@end cartouche
+
+@deftypefun ucs4_t uc_toupper (ucs4_t @var{uc})
+Returns the uppercase mapping of the Unicode character @var{uc}.
+@end deftypefun
+
+@deftypefun ucs4_t uc_tolower (ucs4_t @var{uc})
+Returns the lowercase mapping of the Unicode character @var{uc}.
+@end deftypefun
+
+@deftypefun ucs4_t uc_totitle (ucs4_t @var{uc})
+Returns the titlecase mapping of the Unicode character @var{uc}.
+
+The titlecase mapping of a character is to be used when the character should
+look like upper case and the following characters are lower cased.
+
+For most characters, this is the same as the uppercase mapping. There are
+only few characters where the title case variant and the uuper case variant
+are different. These characters occur in the Latin writing of the Croatian,
+Bosnian, and Serbian languages.
+
+@c Normally we would use .33 space for each column, but this is too much in
+@c TeX mode, see
+@c <http://lists.gnu.org/archive/html/bug-texinfo/2009-05/msg00016.html>.
+@multitable @columnfractions .31 .31 .31
+@headitem Lower case @tab Title case @tab Upper case
+@item LATIN SMALL LETTER LJ
+ @tab LATIN CAPITAL LETTER L WITH SMALL LETTER J
+ @tab LATIN CAPITAL LETTER LJ
+@item LATIN SMALL LETTER NJ
+ @tab LATIN CAPITAL LETTER N WITH SMALL LETTER J
+ @tab LATIN CAPITAL LETTER NJ
+@item LATIN SMALL LETTER DZ
+ @tab LATIN CAPITAL LETTER D WITH SMALL LETTER Z
+ @tab LATIN CAPITAL LETTER DZ
+@item LATIN SMALL LETTER DZ WITH CARON
+ @tab LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON
+ @tab LATIN CAPITAL LETTER DZ WITH CARON
+@end multitable
+@end deftypefun
+
+@node Case mappings of strings
+@section Case mappings of strings
+
+@cindex case mappings
+@cindex uppercasing
+@cindex lowercasing
+@cindex titlecasing
+Case mapping should always be performed on entire strings, not on individual
+characters. The functions in this sections do so.
+
+These functions allow to apply a normalization after the case mapping. The
+reason is that if you want to treat @samp{@"{a}} and @samp{@"{A}} the same,
+you most often also want to treat the composed and decomposed forms of such
+a character, U+00C4 @sc{LATIN CAPITAL LETTER A WITH DIAERESIS} and
+U+0041 @sc{LATIN CAPITAL LETTER A} U+0308 @sc{COMBINING DIAERESIS} the same.
+The @var{nf} argument designates the normalization.
+
+@cindex locale language
+These functions are locale dependent. The @var{iso639_language} argument
+identifies the language (e.g. @code{"tr"} for Turkish). NULL means to use
+locale independent case mappings.
+
+@deftypefun {const char *} uc_locale_language ()
+Returns the ISO 639 language code of the current locale.
+Returns @code{""} if it is unknown, or in the "C" locale.
+@end deftypefun
+
+@deftypefun {uint8_t *} u8_toupper (const uint8_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint8_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint16_t *} u16_toupper (const uint16_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint16_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint32_t *} u32_toupper (const uint32_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint32_t *@var{resultbuf}, size_t *@var{lengthp})
+Returns the uppercase mapping of a string.
+
+The @var{nf} argument identifies the normalization form to apply after the
+case-mapping. It can also be NULL, for no normalization.
+@end deftypefun
+
+@deftypefun {uint8_t *} u8_tolower (const uint8_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint8_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint16_t *} u16_tolower (const uint16_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint16_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint32_t *} u32_tolower (const uint32_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint32_t *@var{resultbuf}, size_t *@var{lengthp})
+Returns the lowercase mapping of a string.
+
+The @var{nf} argument identifies the normalization form to apply after the
+case-mapping. It can also be NULL, for no normalization.
+@end deftypefun
+
+@deftypefun {uint8_t *} u8_totitle (const uint8_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint8_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint16_t *} u16_totitle (const uint16_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint16_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint32_t *} u32_totitle (const uint32_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint32_t *@var{resultbuf}, size_t *@var{lengthp})
+Returns the titlecase mapping of a string.
+
+Mapping to title case means that, in each word, the first cased character
+is being mapped to title case and the remaining characters of the word
+are being mapped to lower case.
+
+The @var{nf} argument identifies the normalization form to apply after the
+case-mapping. It can also be NULL, for no normalization.
+@end deftypefun
+
+@node Case mappings of substrings
+@section Case mappings of substrings
+
+Case mapping of a substring cannot simply be performed by extracting the
+substring and then applying the case mapping function to it. This does not
+work because case mapping requires some information about the surrounding
+characters. The following functions allow to apply case mappings to
+substrings of a given string, while taking into account the characters that
+precede it (the ``prefix'') and the characters that follow it (the ``suffix'').
+
+@deftp Type casing_prefix_context_t
+This data type denotes the case-mapping context that is given by a prefix
+string. It is an immediate type that can be copied by simple assignment,
+without involving memory allocation. It is not an array type.
+@end deftp
+
+@deftypevr Constant casing_prefix_context_t unicase_empty_prefix_context
+This constant is the case-mapping context that corresponds to an empty prefix
+string.
+@end deftypevr
+
+The following functions return @code{casing_prefix_context_t} objects:
+
+@deftypefun casing_prefix_context_t u8_casing_prefix_context (const uint8_t *@var{s}, size_t @var{n})
+@deftypefunx casing_prefix_context_t u16_casing_prefix_context (const uint16_t *@var{s}, size_t @var{n})
+@deftypefunx casing_prefix_context_t u32_casing_prefix_context (const uint32_t *@var{s}, size_t @var{n})
+Returns the case-mapping context of a given prefix string.
+@end deftypefun
+
+@deftypefun casing_prefix_context_t u8_casing_prefixes_context (const uint8_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{a_context})
+@deftypefunx casing_prefix_context_t u16_casing_prefixes_context (const uint16_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{a_context})
+@deftypefunx casing_prefix_context_t u32_casing_prefixes_context (const uint32_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{a_context})
+Returns the case-mapping context of the prefix concat(@var{a}, @var{s}),
+given the case-mapping context of the prefix @var{a}.
+@end deftypefun
+
+@deftp Type casing_suffix_context_t
+This data type denotes the case-mapping context that is given by a suffix
+string. It is an immediate type that can be copied by simple assignment,
+without involving memory allocation. It is not an array type.
+@end deftp
+
+@deftypevr Constant casing_suffix_context_t unicase_empty_suffix_context
+This constant is the case-mapping context that corresponds to an empty suffix
+string.
+@end deftypevr
+
+The following functions return @code{casing_suffix_context_t} objects:
+
+@deftypefun casing_suffix_context_t u8_casing_suffix_context (const uint8_t *@var{s}, size_t @var{n})
+@deftypefunx casing_suffix_context_t u16_casing_suffix_context (const uint16_t *@var{s}, size_t @var{n})
+@deftypefunx casing_suffix_context_t u32_casing_suffix_context (const uint32_t *@var{s}, size_t @var{n})
+Returns the case-mapping context of a given suffix string.
+@end deftypefun
+
+@deftypefun casing_suffix_context_t u8_casing_suffixes_context (const uint8_t *@var{s}, size_t @var{n}, casing_suffix_context_t @var{a_context})
+@deftypefunx casing_suffix_context_t u16_casing_suffixes_context (const uint16_t *@var{s}, size_t @var{n}, casing_suffix_context_t @var{a_context})
+@deftypefunx casing_suffix_context_t u32_casing_suffixes_context (const uint32_t *@var{s}, size_t @var{n}, casing_suffix_context_t @var{a_context})
+Returns the case-mapping context of the suffix concat(@var{s}, @var{a}),
+given the case-mapping context of the suffix @var{a}.
+@end deftypefun
+
+The following functions perform a case mapping, considering the
+prefix context and the suffix context.
+
+@deftypefun {uint8_t *} u8_ct_toupper (const uint8_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{prefix_context}, casing_suffix_context_t @var{suffix_context}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint8_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint16_t *} u16_ct_toupper (const uint16_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{prefix_context}, casing_suffix_context_t @var{suffix_context}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint16_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint32_t *} u32_ct_toupper (const uint32_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{prefix_context}, casing_suffix_context_t @var{suffix_context}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint32_t *@var{resultbuf}, size_t *@var{lengthp})
+Returns the uppercase mapping of a string that is surrounded by a prefix
+and a suffix.
+@end deftypefun
+
+@deftypefun {uint8_t *} u8_ct_tolower (const uint8_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{prefix_context}, casing_suffix_context_t @var{suffix_context}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint8_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint16_t *} u16_ct_tolower (const uint16_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{prefix_context}, casing_suffix_context_t @var{suffix_context}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint16_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint32_t *} u32_ct_tolower (const uint32_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{prefix_context}, casing_suffix_context_t @var{suffix_context}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint32_t *@var{resultbuf}, size_t *@var{lengthp})
+Returns the lowercase mapping of a string that is surrounded by a prefix
+and a suffix.
+@end deftypefun
+
+@deftypefun {uint8_t *} u8_ct_totitle (const uint8_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{prefix_context}, casing_suffix_context_t @var{suffix_context}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint8_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint16_t *} u16_ct_totitle (const uint16_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{prefix_context}, casing_suffix_context_t @var{suffix_context}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint16_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint32_t *} u32_ct_totitle (const uint32_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{prefix_context}, casing_suffix_context_t @var{suffix_context}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint32_t *@var{resultbuf}, size_t *@var{lengthp})
+Returns the titlecase mapping of a string that is surrounded by a prefix
+and a suffix.
+@end deftypefun
+
+For example, to uppercase the UTF-8 substring between @code{s + start_index}
+and @code{s + end_index} of a string that extends from @code{s} to
+@code{s + u8_strlen (s)}, you can use the statements
+
+@smallexample
+size_t result_length;
+uint8_t result =
+ u8_ct_toupper (s + start_index, end_index - start_index,
+ u8_casing_prefix_context (s, start_index),
+ u8_casing_suffix_context (s + end_index,
+ u8_strlen (s) - end_index),
+ iso639_language, NULL, NULL, &result_length);
+@end smallexample
+
+@node Case insensitive comparison
+@section Case insensitive comparison
+
+@cindex comparing, ignoring case
+@cindex comparing, ignoring normalization and case
+The following functions implement comparison that ignores differences in case
+and normalization.
+
+@deftypefun {uint8_t *} u8_casefold (const uint8_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint8_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint16_t *} u16_casefold (const uint16_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint16_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint32_t *} u32_casefold (const uint32_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint32_t *@var{resultbuf}, size_t *@var{lengthp})
+Returns the case folded string.
+
+Comparing @code{u8_casefold (@var{s1})} and @code{u8_casefold (@var{s2})}
+with the @code{u8_cmp2} function is equivalent to comparing @var{s1} and
+@var{s2} with @code{u8_casecmp}.
+
+The @var{nf} argument identifies the normalization form to apply after the
+case-mapping. It can also be NULL, for no normalization.
+@end deftypefun
+
+@deftypefun {uint8_t *} u8_ct_casefold (const uint8_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{prefix_context}, casing_suffix_context_t @var{suffix_context}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint8_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint16_t *} u16_ct_casefold (const uint16_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{prefix_context}, casing_suffix_context_t @var{suffix_context}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint16_t *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {uint32_t *} u32_ct_casefold (const uint32_t *@var{s}, size_t @var{n}, casing_prefix_context_t @var{prefix_context}, casing_suffix_context_t @var{suffix_context}, const char *@var{iso639_language}, uninorm_t @var{nf}, uint32_t *@var{resultbuf}, size_t *@var{lengthp})
+Returns the case folded string. The case folding takes into account the
+case mapping contexts of the prefix and suffix strings.
+@end deftypefun
+
+@deftypefun int u8_casecmp (const uint8_t *@var{s1}, size_t @var{n1}, const uint8_t *@var{s2}, size_t @var{n2}, const char *@var{iso639_language}, uninorm_t @var{nf}, int *@var{resultp})
+@deftypefunx int u16_casecmp (const uint16_t *@var{s1}, size_t @var{n1}, const uint16_t *@var{s2}, size_t @var{n2}, const char *@var{iso639_language}, uninorm_t @var{nf}, int *@var{resultp})
+@deftypefunx int u32_casecmp (const uint32_t *@var{s1}, size_t @var{n1}, const uint32_t *@var{s2}, size_t @var{n2}, const char *@var{iso639_language}, uninorm_t @var{nf}, int *@var{resultp})
+@deftypefunx int ulc_casecmp (const char *@var{s1}, size_t @var{n1}, const char *@var{s2}, size_t @var{n2}, const char *@var{iso639_language}, uninorm_t @var{nf}, int *@var{resultp})
+Compares @var{s1} and @var{s2}, ignoring differences in case and normalization.
+
+The @var{nf} argument identifies the normalization form to apply after the
+case-mapping. It can also be NULL, for no normalization.
+
+If successful, sets @code{*@var{resultp}} to -1 if @var{s1} < @var{s2},
+0 if @var{s1} = @var{s2}, 1 if @var{s1} > @var{s2}, and returns 0.
+Upon failure, returns -1 with @code{errno} set.
+@end deftypefun
+
+@cindex comparing, ignoring case, with collation rules
+@cindex comparing, with collation rules, ignoring case
+@cindex comparing, ignoring normalization and case, with collation rules
+@cindex comparing, with collation rules, ignoring normalization and case
+The following functions additionally take into account the sorting rules of the
+current locale.
+
+@deftypefun {char *} u8_casexfrm (const uint8_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, char *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {char *} u16_casexfrm (const uint16_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, char *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {char *} u32_casexfrm (const uint32_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, char *@var{resultbuf}, size_t *@var{lengthp})
+@deftypefunx {char *} ulc_casexfrm (const char *@var{s}, size_t @var{n}, const char *@var{iso639_language}, uninorm_t @var{nf}, char *@var{resultbuf}, size_t *@var{lengthp})
+Converts the string @var{s} of length @var{n} to a NUL-terminated byte
+sequence, in such a way that comparing @code{u8_casexfrm (@var{s1})} and
+@code{u8_casexfrm (@var{s2})} with the gnulib function @code{memcmp2} is
+equivalent to comparing @var{s1} and @var{s2} with @code{u8_casecoll}.
+
+@var{nf} must be either @code{UNINORM_NFC}, @code{UNINORM_NFKC}, or NULL for
+no normalization.
+@end deftypefun
+
+@deftypefun int u8_casecoll (const uint8_t *@var{s1}, size_t @var{n1}, const uint8_t *@var{s2}, size_t @var{n2}, const char *@var{iso639_language}, uninorm_t @var{nf}, int *@var{resultp})
+@deftypefunx int u16_casecoll (const uint16_t *@var{s1}, size_t @var{n1}, const uint16_t *@var{s2}, size_t @var{n2}, const char *@var{iso639_language}, uninorm_t @var{nf}, int *@var{resultp})
+@deftypefunx int u32_casecoll (const uint32_t *@var{s1}, size_t @var{n1}, const uint32_t *@var{s2}, size_t @var{n2}, const char *@var{iso639_language}, uninorm_t @var{nf}, int *@var{resultp})
+@deftypefunx int ulc_casecoll (const char *@var{s1}, size_t @var{n1}, const char *@var{s2}, size_t @var{n2}, const char *@var{iso639_language}, uninorm_t @var{nf}, int *@var{resultp})
+Compares @var{s1} and @var{s2}, ignoring differences in case and normalization,
+using the collation rules of the current locale.
+
+The @var{nf} argument identifies the normalization form to apply after the
+case-mapping. It must be either @code{UNINORM_NFC} or @code{UNINORM_NFKC}.
+It can also be NULL, for no normalization.
+
+If successful, sets @code{*@var{resultp}} to -1 if @var{s1} < @var{s2},
+0 if @var{s1} = @var{s2}, 1 if @var{s1} > @var{s2}, and returns 0.
+Upon failure, returns -1 with @code{errno} set.
+@end deftypefun
+
+@node Case detection
+@section Case detection
+
+@cindex case detection
+@cindex detecting case
+The following functions determine whether a Unicode string is entirely in
+upper case. or entirely in lower case, or entirely in title case, or already
+case-folded.
+
+@deftypefun int u8_is_uppercase (const uint8_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+@deftypefunx int u16_is_uppercase (const uint16_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+@deftypefunx int u32_is_uppercase (const uint32_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+Sets @code{*@var{resultp}} to true if mapping NFD(@var{s}) to upper case is
+a no-op, or to false otherwise, and returns 0. Upon failure, returns -1 with
+@code{errno} set.
+@end deftypefun
+
+@deftypefun int u8_is_lowercase (const uint8_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+@deftypefunx int u16_is_lowercase (const uint16_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+@deftypefunx int u32_is_lowercase (const uint32_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+Sets @code{*@var{resultp}} to true if mapping NFD(@var{s}) to lower case is
+a no-op, or to false otherwise, and returns 0. Upon failure, returns -1 with
+@code{errno} set.
+@end deftypefun
+
+@deftypefun int u8_is_titlecase (const uint8_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+@deftypefunx int u16_is_titlecase (const uint16_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+@deftypefunx int u32_is_titlecase (const uint32_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+Sets @code{*@var{resultp}} to true if mapping NFD(@var{s}) to title case is
+a no-op, or to false otherwise, and returns 0. Upon failure, returns -1 with
+@code{errno} set.
+@end deftypefun
+
+@deftypefun int u8_is_casefolded (const uint8_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+@deftypefunx int u16_is_casefolded (const uint16_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+@deftypefunx int u32_is_casefolded (const uint32_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+Sets @code{*@var{resultp}} to true if applying case folding to NFD(@var{S}) is
+a no-op, or to false otherwise, and returns 0. Upon failure, returns -1 with
+@code{errno} set.
+@end deftypefun
+
+The following functions determine whether case mappings have any effect on a
+Unicode string.
+
+@deftypefun int u8_is_cased (const uint8_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+@deftypefunx int u16_is_cased (const uint16_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+@deftypefunx int u32_is_cased (const uint32_t *@var{s}, size_t @var{n}, const char *@var{iso639_language}, bool *@var{resultp})
+Sets @code{*@var{resultp}} to true if case matters for @var{s}, that is, if
+mapping NFD(@var{s}) to either upper case or lower case or title case is not
+a no-op. Set @code{*@var{resultp}} to false if NFD(@var{s}) maps to itself
+under the upper case mapping, under the lower case mapping, and under the title
+case mapping; in other words, when NFD(@var{s}) consists entirely of caseless
+characters. Upon failure, returns -1 with @code{errno} set.
+@end deftypefun