Imported Upstream version 0.9.1upstream/0.9.1

1 files changed, 6200 insertions, 0 deletions

diff --git a/doc/libunistring.info b/doc/libunistring.info
new file mode 100644
index 00000000..2fad8fec
--- /dev/null
+++ b/doc/libunistring.info
@@ -0,0 +1,6200 @@
+This is libunistring.info, produced by makeinfo version 4.13 from
+libunistring.texi.
+
+INFO-DIR-SECTION Software development
+START-INFO-DIR-ENTRY
+* GNU libunistring: (libunistring).     Unicode string library.
+END-INFO-DIR-ENTRY
+
+   This manual is for GNU libunistring.
+
+
+File: libunistring.info,  Node: Top,  Next: Introduction,  Up: (dir)
+
+GNU libunistring
+****************
+
+* Menu:
+
+* Introduction::                Who may need Unicode strings?
+* Conventions::                 Conventions used in this manual
+* unitypes.h::                  Elementary types
+* unistr.h::                    Elementary Unicode string functions
+* uniconv.h::                   Conversions between Unicode and encodings
+* unistdio.h::                  Output with Unicode strings
+* uniname.h::                   Names of Unicode characters
+* unictype.h::                  Unicode character classification and properties
+* uniwidth.h::                  Display width
+* uniwbrk.h::                   Word breaks in strings
+* unilbrk.h::                   Line breaking
+* uninorm.h::                   Normalization forms
+* unicase.h::                   Case mappings
+* uniregex.h::                  Regular expressions
+* Using the library::           How to link with the library and use it?
+* More functionality::          More advanced functionality
+* Licenses::                    Licenses
+
+* Index::                       General Index
+
+ --- The Detailed Node Listing ---
+
+Introduction
+
+* Unicode::                     What is Unicode?
+* Unicode and i18n::            Unicode and internationalization
+* Locale encodings::            What is a locale encoding?
+* In-memory representation::    How to represent strings in memory?
+* char * strings::              What to keep in mind with `char *' strings
+* The wchar_t mess::            Why `wchar_t *' strings are useless
+* Unicode strings::             How are Unicode strings represented?
+
+unistr.h
+
+* Elementary string checks::
+* Elementary string conversions::
+* Elementary string functions::
+* Elementary string functions with memory allocation::
+* Elementary string functions on NUL terminated strings::
+
+unictype.h
+
+* General category::
+* Canonical combining class::
+* Bidirectional category::
+* Decimal digit value::
+* Digit value::
+* Numeric value::
+* Mirrored character::
+* Properties::
+* Scripts::
+* Blocks::
+* ISO C and Java syntax::
+* Classifications like in ISO C::
+
+General category
+
+* Object oriented API::
+* Bit mask API::
+
+Properties
+
+* Properties as objects::
+* Properties as functions::
+
+uniwbrk.h
+
+* Word breaks in a string::
+* Word break property::
+
+uninorm.h
+
+* Decomposition of characters::
+* Composition of characters::
+* Normalization of strings::
+* Normalizing comparisons::
+* Normalization of streams::
+
+unicase,h
+
+* Case mappings of characters::
+* Case mappings of strings::
+* Case mappings of substrings::
+* Case insensitive comparison::
+* Case detection::
+
+Using the library
+
+* Installation::
+* Compiler options::
+* Include files::
+* Autoconf macro::
+* Reporting problems::
+
+Licenses
+
+* GNU GPL::                     GNU General Public License
+* GNU LGPL::                    GNU Lesser General Public License
+* GNU FDL::                     GNU Free Documentation License
+
+
+File: libunistring.info,  Node: Introduction,  Next: Conventions,  Prev: Top,  Up: Top
+
+1 Introduction
+**************
+
+   This library provides functions for manipulating Unicode strings and
+for manipulating C strings according to the Unicode standard.
+
+   It consists of the following parts:
+
+`<unistr.h>'
+     elementary string functions
+
+`<uniconv.h>'
+     conversion from/to legacy encodings
+
+`<unistdio.h>'
+     formatted output to strings
+
+`<uniname.h>'
+     character names
+
+`<unictype.h>'
+     character classification and properties
+
+`<uniwidth.h>'
+     string width when using nonproportional fonts
+
+`<uniwbrk.h>'
+     word breaks
+
+`<unilbrk.h>'
+     line breaking algorithm
+
+`<uninorm.h>'
+     normalization (composition and decomposition)
+
+`<unicase.h>'
+     case folding
+
+`<uniregex.h>'
+     regular expressions (not yet implemented)
+
+   libunistring is for you if your application involves non-trivial text
+processing, such as upper/lower case conversions, line breaking,
+operations on words, or more advanced analysis of text.  Text provided
+by the user can, in general, contain characters of all kinds of
+scripts.  The text processing functions provided by this library handle
+all scripts and all languages.
+
+   libunistring is for you if your application already uses the ISO C /
+POSIX `<ctype.h>', `<wctype.h>' functions and the text it operates on is
+provided by the user and can be in any language.
+
+   libunistring is also for you if your application uses Unicode
+strings as internal in-memory representation.
+
+* Menu:
+
+* Unicode::                     What is Unicode?
+* Unicode and i18n::            Unicode and internationalization
+* Locale encodings::            What is a locale encoding?
+* In-memory representation::    How to represent strings in memory?
+* char * strings::              What to keep in mind with `char *' strings
+* The wchar_t mess::            Why `wchar_t *' strings are useless
+* Unicode strings::             How are Unicode strings represented?
+
+
+File: libunistring.info,  Node: Unicode,  Next: Unicode and i18n,  Up: Introduction
+
+1.1 Unicode
+===========
+
+   Unicode is a standardized repertoire of characters that contains
+characters from all scripts of the world, from Latin letters to Chinese
+ideographs and Babylonian cuneiform glyphs.  It also specifies how
+these characters are to be rendered on a screen or on paper, and how
+common text processing (word selection, line breaking, uppercasing of
+page titles etc.) is supposed to behave on Unicode text.
+
+   Unicode also specifies three ways of storing sequences of Unicode
+characters in a computer whose basic unit of data is an 8-bit byte: 
+UTF-8
+     Every character is represented as 1 to 4 bytes.
+
+UTF-16
+     Every character is represented as 1 to 2 units of 16 bits.
+
+UTF-32, a.k.a. UCS-4
+     Every character is represented as 1 unit of 32 bits.
+
+   For encoding Unicode text in a file, UTF-8 is usually used.  For
+encoding Unicode strings in memory for a program, either of the three
+encoding forms can be reasonably used.
+
+   Unicode is widely used on the web.  Prior to the use of Unicode, web
+pages were in many different encodings (ISO-8859-1 for English, French,
+Spanish, ISO-8859-2 for Polish, ISO-8859-7 for Greek, KOI8-R for
+Russian, GB2312 or BIG5 for Chinese, ISO-2022-JP-2 or EUC-JP or
+Shift_JIS for Japanese, and many many others).  It was next to
+impossible to create a document that contained Chinese and Polish text
+in the same document.  Due to the many encodings for Japanese, even the
+processing of pure Japanese text was error prone.
+
+   References:
+   * The Unicode standard: `http://www.unicode.org/'
+
+   * Definition of UTF-8: `http://www.rfc-editor.org/rfc/rfc3629.txt'
+
+   * Definition of UTF-16: `http://www.rfc-editor.org/rfc/rfc2781.txt'
+
+   * Markus Kuhn's UTF-8 and Unicode FAQ:
+     `http://www.cl.cam.ac.uk/~mgk25/unicode.html'
+
+
+File: libunistring.info,  Node: Unicode and i18n,  Next: Locale encodings,  Prev: Unicode,  Up: Introduction
+
+1.2 Unicode and Internationalization
+====================================
+
+   Internationalization is the process of changing the source code of a
+program so that it can meet the expectations of users in any culture,
+if culture specific data (translations, images etc.) are provided.
+
+   Use of Unicode is not strictly required for internationalization,
+but it makes internationalization much easier, because operations that
+need to look at specific characters (like hyphenation, spell checking,
+or the automatic conversion of double-quotes to opening and closing
+double-quote characters) don't need to consider multiple possible
+encodings of the text.
+
+   Use of Unicode also enables multilingualization: the ability of
+having text in multiple languages present in the same document or even
+in the same line of text.
+
+   But use of Unicode is not everything.  Internationalization usually
+consists of three features:
+   * Use of Unicode where needed for text processing.  This is what
+     this library is for.
+
+   * Use of message catalogs for messages shown to the user, This is
+     what GNU gettext is about.
+
+   * Use of locale specific conventions for date and time formats, for
+     numeric formatting, or for sorting of text.  This can be done
+     adequately with the POSIX APIs and the implementation of locales
+     in the GNU C library.
+
+
+File: libunistring.info,  Node: Locale encodings,  Next: In-memory representation,  Prev: Unicode and i18n,  Up: Introduction
+
+1.3 Locale encodings
+====================
+
+   A locale is a set of cultural conventions.  According to POSIX, for
+a program, at any moment, there is one locale being designated as the
+"current locale".  (Actually, POSIX supports also one locale per
+thread, but this feature is not yet universally implemented and not
+widely used.)  The locale is partitioned into several aspects, called
+the "categories" of the locale.  The main various aspects are:
+   * The character encoding and the character properties.  This is the
+     `LC_CTYPE' category.
+
+   * The sorting rules for text.  This is the `LC_COLLATE' category.
+
+   * The language specific translations of messages.  This is the
+     `LC_MESSAGES' category.
+
+   * The formatting rules for numbers, such as the decimal separator.
+     This is the `LC_NUMERIC' category.
+
+   * The formatting rules for amounts of money.  This is the
+     `LC_MONETARY' category.
+
+   * The formatting of date and time.  This is the `LC_TIME' category.
+
+   In particular, the `LC_CTYPE' category of the current locale
+determines the character encoding.  This is the encoding of `char *'
+strings.  We also call it the "locale encoding".  GNU libunistring has
+a function, `locale_charset', that returns a standardized (platform
+independent) name for this encoding.
+
+   All locale encodings used on glibc systems are essentially ASCII
+compatible: Most graphic ASCII characters have the same representation,
+as a single byte, in that encoding as in ASCII.
+
+   Among the possible locale encodings are UTF-8 and GB18030.  Both
+allow to represent any Unicode character as a sequence of bytes.  UTF-8
+is used in most of the world, whereas GB18030 is used in the People's
+Republic of China, because it is backward compatible with the GB2312
+encoding that was used in this country earlier.
+
+   The legacy locale encodings, ISO-8859-15 (which supplanted
+ISO-8859-1 in most of Europe), ISO-8859-2, KOI8-R, EUC-JP, etc., are
+still in use in many places, though.
+
+   UTF-16 and UTF-32 are not used as locale encodings, because they are
+not ASCII compatible.
+
+
+File: libunistring.info,  Node: In-memory representation,  Next: char * strings,  Prev: Locale encodings,  Up: Introduction
+
+1.4 Choice of in-memory representation of strings
+=================================================
+
+   There are three ways of representing strings in memory of a running
+program.
+   * As `char *' strings.  Such strings are represented in locale
+     encoding.  This approach is employed when not much text processing
+     is done by the program.  When some Unicode aware processing is to
+     be done, a string is converted to Unicode on the fly and back to
+     locale encoding afterwards.
+
+   * As UTF-8 or UTF-16 or UTF-32 strings.  This implies that
+     conversion from locale encoding to Unicode is performed on input,
+     and in the opposite direction on output.  This approach is
+     employed when the program does a significant amount of text
+     processing, or when the program has multiple threads operating on
+     the same data but in different locales.
+
+   * As `wchar_t *', a.k.a. "wide strings".  This approach is misguided,
+     see *note The wchar_t mess::.
+
+
+File: libunistring.info,  Node: char * strings,  Next: The wchar_t mess,  Prev: In-memory representation,  Up: Introduction
+
+1.5 `char *' strings
+====================
+
+   The classical C strings, with its C library support standardized by
+ISO C and POSIX, can be used in internationalized programs with some
+precautions.  The problem with this API is that many of the C library
+functions for strings don't work correctly on strings in locale
+encodings, leading to bugs that only people in some cultures of the
+world will experience.
+
+   The first problem with the C library API is the support of multibyte
+locales.  According to the locale encoding, in general, every character
+is represented by one or more bytes (up to 4 bytes in practice -- but
+use `MB_LEN_MAX' instead of the number 4 in the code).  When every
+character is represented by only 1 byte, we speak of an "unibyte
+locale", otherwise of a "multibyte locale".  It is important to realize
+that the majority of Unix installations nowadays use UTF-8 or GB18030
+as locale encoding; therefore, the majority of users are using
+multibyte locales.
+
+   The important fact to remember is: _A `char' is a byte, not a
+character._
+
+   As a consequence:
+   * The `<ctype.h>' API is useless in this context; it does not work in
+     multibyte locales.
+
+   * The `strlen' function does not return the number of characters in
+     a string.  Nor does it return the number of screen columns occupied
+     by a string after it is output.  It merely returns the number of
+     _bytes_ occupied by a string.
+
+   * Truncating a string, for example, with `strncpy', can have the
+     effect of truncating it in the middle of a multibyte character.
+     Such a string will, when output, have a garbled character at its
+     end, often represented by a hollow box.
+
+   * `strchr' and `strrchr' do not work with multibyte strings if the
+     locale encoding is GB18030 and the character to be searched is a
+     digit.
+
+   * `strstr' does not work with multibyte strings if the locale
+     encoding is different from UTF-8.
+
+   * `strcspn', `strpbrk', `strspn' cannot work correctly in multibyte
+     locales: they assume the second argument is a list of single-byte
+     characters.  Even in this simple case, they do not work with
+     multibyte strings if the locale encoding is GB18030 and one of the
+     characters to be searched is a digit.
+
+   * `strsep' and `strtok_r' do not work with multibyte strings unless
+     all of the delimiter characters are ASCII characters < 0x30.
+
+   * The `strcasecmp', `strncasecmp', and `strcasestr' functions do not
+     work with multibyte strings.
+
+   The workarounds can be found in GNU gnulib
+`http://www.gnu.org/software/gnulib/'.
+   * gnulib has modules `mbchar', `mbiter', `mbuiter' that represent
+     multibyte characters and allow to iterate across a multibyte
+     string with the same ease as through a unibyte string.
+
+   * gnulib has functions `mbslen' and `mbswidth' that can be used
+     instead of `strlen' when the number of characters or the number of
+     screen columns of a string is requested.
+
+   * gnulib has functions `mbschr' and `mbsrrchr' that are like
+     `strchr' and `strrchr', but work in multibyte locales.
+
+   * gnulib has a function `mbsstr', like `strstr', but works in
+     multibyte locales.
+
+   * gnulib has functions `mbscspn', `mbspbrk', `mbsspn' that are like
+     `strcspn', `strpbrk', `strspn', but work in multibyte locales.
+
+   * gnulib has functions `mbssep' and `mbstok_r' that are like
+     `strsep' and `strtok_r' but work in multibyte locales.
+
+   * gnulib has functions `mbscasecmp', `mbsncasecmp', `mbspcasecmp',
+     and `mbscasestr' that are like `strcasecmp', `strncasecmp', and
+     `strcasestr', but work in multibyte locales.  Still, the function
+     `ulc_casecmp' is preferable to these functions; see below.
+
+   The second problem with the C library API is that it has some
+assumptions built-in that are not valid in some languages:
+   * It assumes that there are only two forms of every character:
+     uppercase and lowercase.  This is not true for Croatian, where the
+     character LETTER DZ WITH CARON comes in three forms: LATIN CAPITAL
+     LETTER DZ WITH CARON (DZ), LATIN CAPITAL LETTER D WITH SMALL
+     LETTER Z WITH CARON (Dz), LATIN SMALL LETTER DZ WITH CARON (dz).
+
+   * It assumes that uppercasing of 1 character leads to 1 character.
+     This is not true for German, where the LATIN SMALL LETTER SHARP S,
+     when uppercased, becomes `SS'.
+
+   * It assumes that there is 1:1 mapping between uppercase and
+     lowercase forms.  This is not true for the Greek sigma: GREEK
+     CAPITAL LETTER SIGMA is the uppercase of both GREEK SMALL LETTER
+     SIGMA and GREEK SMALL LETTER FINAL SIGMA.
+
+   * It assumes that the upper/lowercase mappings are position
+     independent.  This is not true for the Greek sigma and the
+     Lithuanian i.
+
+   The correct way to deal with this problem is
+  1. to provide functions for titlecasing, as well as for upper- and
+     lowercasing,
+
+  2. to view case transformations as functions that operates on strings,
+     rather than on characters.
+
+   This is implemented in this library, through the functions declared
+in `<unicase.h>', see *note unicase.h::.
+
+
+File: libunistring.info,  Node: The wchar_t mess,  Next: Unicode strings,  Prev: char * strings,  Up: Introduction
+
+1.6 The `wchar_t' mess
+======================
+
+   The ISO C and POSIX standard creators made an attempt to fix the
+first problem mentioned in the previous section.  They introduced
+   * a type `wchar_t', designed to encapsulate an entire character,
+
+   * a "wide string" type `wchar_t *', and
+
+   * functions declared in `<wctype.h>' that were meant to supplant the
+     ones in `<ctype.h>'.
+
+   Unfortunately, this API and its implementation has numerous problems:
+
+   * On AIX and Windows platforms, `wchar_t' is a 16-bit type.  This
+     means that it can never accommodate an entire Unicode character.
+     Either the `wchar_t *' strings are limited to characters in UCS-2
+     (the "Basic Multilingual Plane" of Unicode), or -- if `wchar_t *'
+     strings are encoded in UTF-16 -- a `wchar_t' represents only half
+     of a character in the worst case, making the `<wctype.h>' functions
+     pointless.
+
+   * On Solaris and FreeBSD, the `wchar_t' encoding is locale dependent
+     and undocumented.  This means, if you want to know any property of
+     a `wchar_t' character, other than the properties defined by
+     `<wctype.h>' -- such as whether it's a dash, currency symbol,
+     paragraph separator, or similar --, you have to convert it to
+     `char *' encoding first, by use of the function `wctomb'.
+
+   * When you read a stream of wide characters, through the functions
+     `fgetwc' and `fgetws', and when the input stream/file is not in
+     the expected encoding, you have no way to determine the invalid
+     byte sequence and do some corrective action.  If you use these
+     functions, your program becomes "garbage in - more garbage out" or
+     "garbage in - abort".
+
+   As a consequence, it is better to use multibyte strings, as
+explained in the previous section.  Such multibyte strings can bypass
+limitations of the `wchar_t' type, if you use functions defined in
+gnulib and libunistring for text processing.  They can also faithfully
+transport malformed characters that were present in the input, without
+requiring the program to produce garbage or abort.
+
+
+File: libunistring.info,  Node: Unicode strings,  Prev: The wchar_t mess,  Up: Introduction
+
+1.7 Unicode strings
+===================
+
+   libunistring supports Unicode strings in three representations: 
+   * UTF-8 strings, through the type `uint8_t *'.  The units are bytes
+     (`uint8_t').
+
+   * UTF-16 strings, through the type `uint16_t *',  The units are
+     16-bit memory words (`uint16_t').
+
+   * UTF-32 strings, through the type `uint32_t *'.  The units are
+     32-bit memory words (`uint32_t').
+
+   As with C strings, there are two variants:
+   * Unicode strings with a terminating NUL character are represented as
+     a pointer to the first unit of the string.  There is a unit
+     containing a 0 value at the end.  It is considered part of the
+     string for all memory allocation purposes, but is not considered
+     part of the string for all other logical purposes.
+
+   * Unicode strings where embedded NUL characters are allowed.  These
+     are represented by a pointer to the first unit and the number of
+     units (not bytes!) of the string.  In this setting, there is no
+     trailing zero-valued unit used as "end marker".
+
+
+File: libunistring.info,  Node: Conventions,  Next: unitypes.h,  Prev: Introduction,  Up: Top
+
+2 Conventions
+*************
+
+   This chapter explains conventions valid throughout the libunistring
+library.
+
+   Variables of type `char *' denote C strings in locale encoding.  See
+*note Locale encodings::.
+
+   Variables of type `uint8_t *' denote UTF-8 strings.  Their units are
+bytes.
+
+   Variables of type `uint16_t *' denote UTF-16 strings, without byte
+order mark.  Their units are 2-byte words.
+
+   Variables of type `uint32_t *' denote UTF-32 strings, without byte
+order mark.  Their units are 4-byte words.
+
+   Argument pairs `(S, N)' denote a string `S[0..N-1]' with exactly N
+units.
+
+   All functions with prefix `ulc_' operate on C strings in locale
+encoding.
+
+   All functions with prefix `u8_' operate on UTF-8 strings.
+
+   All functions with prefix `u16_' operate on UTF-16 strings.
+
+   All functions with prefix `u32_' operate on UTF-32 strings.
+
+   For every function with prefix `u8_', operating on UTF-8 strings,
+there is also a corresponding function with prefix `u16_', operating on
+UTF-16 strings, and a corresponding function with prefix `u32_',
+operating on UTF-32 strings.  Their description is analogous; in this
+documentation we describe only the function that operates on UTF-8
+strings, for brevity.
+
+   A declaration with a variable N denotes the three concrete
+declarations with N = 8, N = 16, N = 32.
+
+   All parameters starting with `str' and the parameters of functions
+starting with `u8_str'/`u16_str'/`u32_str' denote a NUL terminated
+string.
+
+   Error values are always returned through the `errno' variable,
+usually with a return value that indicates the presence of an error
+(NULL for functions that return an pointer, or -1 for functions that
+return an `int').
+
+   Functions returning a string result take a `(RESULTBUF, LENGTHP)'
+argument pair.  If RESULTBUF is not NULL and the result fits into
+`*LENGTHP' units, it is put in RESULTBUF, and RESULTBUF is returned.
+Otherwise, a freshly allocated string is returned.  In both cases,
+`*LENGTHP' is set to the length (number of units) of the returned
+string.  In case of error, NULL is returned and `errno' is set.
+
+
+File: libunistring.info,  Node: unitypes.h,  Next: unistr.h,  Prev: Conventions,  Up: Top
+
+3 Elementary types `<unitypes.h>'
+*********************************
+
+   The include file `<unitypes.h>' provides the following basic types.
+
+ -- Type: uint8_t
+ -- Type: uint16_t
+ -- Type: uint32_t
+     These are the storage units of UTF-8/16/32 strings, respectively.
+     The definitions are taken from `<stdint.h>', on platforms where
+     this include file is present.
+
+ -- Type: ucs4_t
+     This type represents a single Unicode character, outside of an
+     UTF-32 string.
+
+
+File: libunistring.info,  Node: unistr.h,  Next: uniconv.h,  Prev: unitypes.h,  Up: Top
+
+4 Elementary Unicode string functions `<unistr.h>'
+**************************************************
+
+   This include file declares elementary functions for Unicode strings.
+It is essentially the equivalent of what `<string.h>' is for C strings.
+
+* Menu:
+
+* Elementary string checks::
+* Elementary string conversions::
+* Elementary string functions::
+* Elementary string functions with memory allocation::
+* Elementary string functions on NUL terminated strings::
+
+
+File: libunistring.info,  Node: Elementary string checks,  Next: Elementary string conversions,  Up: unistr.h
+
+4.1 Elementary string checks
+============================
+
+   The following function is available to verify the integrity of a
+Unicode string.
+
+ -- Function: const uint8_t * u8_check (const uint8_t *S, size_t N)
+ -- Function: const uint16_t * u16_check (const uint16_t *S, size_t N)
+ -- Function: const uint32_t * u32_check (const uint32_t *S, size_t N)
+     This function checks whether a Unicode string is well-formed.  It
+     returns NULL if valid, or a pointer to the first invalid unit
+     otherwise.
+
+
+File: libunistring.info,  Node: Elementary string conversions,  Next: Elementary string functions,  Prev: Elementary string checks,  Up: unistr.h
+
+4.2 Elementary string conversions
+=================================
+
+   The following functions perform conversions between the different
+forms of Unicode strings.
+
+ -- Function: uint16_t * u8_to_u16 (const uint8_t *S, size_t N,
+          uint16_t *RESULTBUF, size_t *LENGTHP)
+     Converts an UTF-8 string to an UTF-16 string.
+
+ -- Function: uint32_t * u8_to_u32 (const uint8_t *S, size_t N,
+          uint32_t *RESULTBUF, size_t *LENGTHP)
+     Converts an UTF-8 string to an UTF-32 string.
+
+ -- Function: uint8_t * u16_to_u8 (const uint16_t *S, size_t N, uint8_t
+          *RESULTBUF, size_t *LENGTHP)
+     Converts an UTF-16 string to an UTF-8 string.
+
+ -- Function: uint32_t * u16_to_u32 (const uint16_t *S, size_t N,
+          uint32_t *RESULTBUF, size_t *LENGTHP)
+     Converts an UTF-16 string to an UTF-32 string.
+
+ -- Function: uint8_t * u32_to_u8 (const uint32_t *S, size_t N, uint8_t
+          *RESULTBUF, size_t *LENGTHP)
+     Converts an UTF-32 string to an UTF-8 string.
+
+ -- Function: uint16_t * u32_to_u16 (const uint32_t *S, size_t N,
+          uint16_t *RESULTBUF, size_t *LENGTHP)
+     Converts an UTF-32 string to an UTF-16 string.
+
+
+File: libunistring.info,  Node: Elementary string functions,  Next: Elementary string functions with memory allocation,  Prev: Elementary string conversions,  Up: unistr.h
+
+4.3 Elementary string functions
+===============================
+
+   The following functions inspect and return details about the first
+character in a Unicode string.
+
+ -- Function: int u8_mblen (const uint8_t *S, size_t N)
+ -- Function: int u16_mblen (const uint16_t *S, size_t N)
+ -- Function: int u32_mblen (const uint32_t *S, size_t N)
+     Returns the length (number of units) of the first character in S,
+     which is no longer than N.  Returns 0 if it is the NUL character.
+     Returns -1 upon failure.
+
+     This function is similar to `mblen', except that it operates on a
+     Unicode string and that S must not be NULL.
+
+ -- Function: int u8_mbtouc_unsafe (ucs4_t *PUC, const uint8_t *S,
+          size_t N)
+ -- Function: int u16_mbtouc_unsafe (ucs4_t *PUC, const uint16_t *S,
+          size_t N)
+ -- Function: int u32_mbtouc_unsafe (ucs4_t *PUC, const uint32_t *S,
+          size_t N)
+     Returns the length (number of units) of the first character in S,
+     putting its `ucs4_t' representation in `*PUC'.  Upon failure,
+     `*PUC' is set to `0xfffd', and an appropriate number of units is
+     returned.
+
+     The number of available units, N, must be > 0.
+
+     This function is similar to `mbtowc', except that it operates on a
+     Unicode string, PUC and S must not be NULL, N must be > 0, and the
+     NUL character is not treated specially.
+
+ -- Function: int u8_mbtouc (ucs4_t *PUC, const uint8_t *S, size_t N)
+ -- Function: int u16_mbtouc (ucs4_t *PUC, const uint16_t *S, size_t N)
+ -- Function: int u32_mbtouc (ucs4_t *PUC, const uint32_t *S, size_t N)
+     This function is like `u8_mbtouc_unsafe', except that it will
+     detect an invalid UTF-8 character, even if the library is compiled
+     without `--enable-safety'.
+
+ -- Function: int u8_mbtoucr (ucs4_t *PUC, const uint8_t *S, size_t N)
+ -- Function: int u16_mbtoucr (ucs4_t *PUC, const uint16_t *S, size_t N)
+ -- Function: int u32_mbtoucr (ucs4_t *PUC, const uint32_t *S, size_t N)
+     Returns the length (number of units) of the first character in S,
+     putting its `ucs4_t' representation in `*PUC'.  Upon failure,
+     `*PUC' is set to `0xfffd', and -1 is returned for an invalid
+     sequence of units, -2 is returned for an incomplete sequence of
+     units.
+
+     The number of available units, N, must be > 0.
+
+     This function is similar to `u8_mbtouc', except that the return
+     value gives more details about the failure, similar to `mbrtowc'.
+
+   The following function stores a Unicode character as a Unicode
+string in memory.
+
+ -- Function: int u8_uctomb (uint8_t *S, ucs4_t UC, int N)
+ -- Function: int u16_uctomb (uint16_t *S, ucs4_t UC, int N)
+ -- Function: int u32_uctomb (uint32_t *S, ucs4_t UC, int N)
+     Puts the multibyte character represented by UC in S, returning its
+     length.  Returns -1 upon failure, -2 if the number of available
+     units, N, is too small.  The latter case cannot occur if N >=
+     6/2/1, respectively.
+
+     This function is similar to `wctomb', except that it operates on a
+     Unicode strings, S must not be NULL, and the argument N must be
+     specified.
+
+   The following functions copy Unicode strings in memory.
+
+ -- Function: uint8_t * u8_cpy (uint8_t *DEST, const uint8_t *SRC,
+          size_t N)
+ -- Function: uint16_t * u16_cpy (uint16_t *DEST, const uint16_t *SRC,
+          size_t N)
+ -- Function: uint32_t * u32_cpy (uint32_t *DEST, const uint32_t *SRC,
+          size_t N)
+     Copies N units from SRC to DEST.
+
+     This function is similar to `memcpy', except that it operates on
+     Unicode strings.
+
+ -- Function: uint8_t * u8_move (uint8_t *DEST, const uint8_t *SRC,
+          size_t N)
+ -- Function: uint16_t * u16_move (uint16_t *DEST, const uint16_t *SRC,
+          size_t N)
+ -- Function: uint32_t * u32_move (uint32_t *DEST, const uint32_t *SRC,
+          size_t N)
+     Copies N units from SRC to DEST, guaranteeing correct behavior for
+     overlapping memory areas.
+
+     This function is similar to `memmove', except that it operates on
+     Unicode strings.
+
+   The following function fills a Unicode string.
+
+ -- Function: uint8_t * u8_set (uint8_t *S, ucs4_t UC, size_t N)
+ -- Function: uint16_t * u16_set (uint16_t *S, ucs4_t UC, size_t N)
+ -- Function: uint32_t * u32_set (uint32_t *S, ucs4_t UC, size_t N)
+     Sets the first N characters of S to UC.  UC should be a character
+     that occupies only 1 unit.
+
+     This function is similar to `memset', except that it operates on
+     Unicode strings.
+
+   The following function compares two Unicode strings of the same
+length.
+
+ -- Function: int u8_cmp (const uint8_t *S1, const uint8_t *S2, size_t
+          N)
+ -- Function: int u16_cmp (const uint16_t *S1, const uint16_t *S2,
+          size_t N)
+ -- Function: int u32_cmp (const uint32_t *S1, const uint32_t *S2,
+          size_t N)
+     Compares S1 and S2, each of length N, lexicographically.  Returns
+     a negative value if S1 compares smaller than S2, a positive value
+     if S1 compares larger than S2, or 0 if they compare equal.
+
+     This function is similar to `memcmp', except that it operates on
+     Unicode strings.
+
+   The following function compares two Unicode strings of possibly
+different lengths.
+
+ -- Function: int u8_cmp2 (const uint8_t *S1, size_t N1, const uint8_t
+          *S2, size_t N2)
+ -- Function: int u16_cmp2 (const uint16_t *S1, size_t N1, const
+          uint16_t *S2, size_t N2)
+ -- Function: int u32_cmp2 (const uint32_t *S1, size_t N1, const
+          uint32_t *S2, size_t N2)
+     Compares S1 and S2, lexicographically.  Returns a negative value
+     if S1 compares smaller than S2, a positive value if S1 compares
+     larger than S2, or 0 if they compare equal.
+
+     This function is similar to the gnulib function `memcmp2', except
+     that it operates on Unicode strings.
+
+   The following function searches for a given Unicode character.
+
+ -- Function: uint8_t * u8_chr (const uint8_t *S, size_t N, ucs4_t UC)
+ -- Function: uint16_t * u16_chr (const uint16_t *S, size_t N, ucs4_t
+          UC)
+ -- Function: uint32_t * u32_chr (const uint32_t *S, size_t N, ucs4_t
+          UC)
+     Searches the string at S for UC.  Returns a pointer to the first
+     occurrence of UC in S, or NULL if UC does not occur in S.
+
+     This function is similar to `memchr', except that it operates on
+     Unicode strings.
+
+   The following function counts the number of Unicode characters.
+
+ -- Function: size_t u8_mbsnlen (const uint8_t *S, size_t N)
+ -- Function: size_t u16_mbsnlen (const uint16_t *S, size_t N)
+ -- Function: size_t u32_mbsnlen (const uint32_t *S, size_t N)
+     Counts and returns the number of Unicode characters in the N units
+     from S.
+
+     This function is similar to the gnulib function `mbsnlen', except
+     that it operates on Unicode strings.
+
+
+File: libunistring.info,  Node: Elementary string functions with memory allocation,  Next: Elementary string functions on NUL terminated strings,  Prev: Elementary string functions,  Up: unistr.h
+
+4.4 Elementary string functions with memory allocation
+======================================================
+
+   The following function copies a Unicode string.
+
+ -- Function: uint8_t * u8_cpy_alloc (const uint8_t *S, size_t N)
+ -- Function: uint16_t * u16_cpy_alloc (const uint16_t *S, size_t N)
+ -- Function: uint32_t * u32_cpy_alloc (const uint32_t *S, size_t N)
+     Makes a freshly allocated copy of S, of length N.
+
+
+File: libunistring.info,  Node: Elementary string functions on NUL terminated strings,  Prev: Elementary string functions with memory allocation,  Up: unistr.h
+
+4.5 Elementary string functions on NUL terminated strings
+=========================================================
+
+   The following functions inspect and return details about the first
+character in a Unicode string.
+
+ -- Function: int u8_strmblen (const uint8_t *S)
+ -- Function: int u16_strmblen (const uint16_t *S)
+ -- Function: int u32_strmblen (const uint32_t *S)
+     Returns the length (number of units) of the first character in S.
+     Returns 0 if it is the NUL character.  Returns -1 upon failure.
+
+ -- Function: int u8_strmbtouc (ucs4_t *PUC, const uint8_t *S)
+ -- Function: int u16_strmbtouc (ucs4_t *PUC, const uint16_t *S)
+ -- Function: int u32_strmbtouc (ucs4_t *PUC, const uint32_t *S)
+     Returns the length (number of units) of the first character in S,
+     putting its `ucs4_t' representation in `*PUC'.  Returns 0 if it is
+     the NUL character.  Returns -1 upon failure.
+
+ -- Function: const uint8_t * u8_next (ucs4_t *PUC, const uint8_t *S)
+ -- Function: const uint16_t * u16_next (ucs4_t *PUC, const uint16_t *S)
+ -- Function: const uint32_t * u32_next (ucs4_t *PUC, const uint32_t *S)
+     Forward iteration step.  Advances the pointer past the next
+     character, or returns NULL if the end of the string has been
+     reached.  Puts the character's `ucs4_t' representation in `*PUC'.
+
+   The following function inspects and returns details about the
+previous character in a Unicode string.
+
+ -- Function: const uint8_t * u8_prev (ucs4_t *PUC, const uint8_t *S,
+          const uint8_t *START)
+ -- Function: const uint16_t * u16_prev (ucs4_t *PUC, const uint16_t
+          *S, const uint16_t *START)
+ -- Function: const uint32_t * u32_prev (ucs4_t *PUC, const uint32_t
+          *S, const uint32_t *START)
+     Backward iteration step.  Advances the pointer to point to the
+     previous character, or returns NULL if the beginning of the string
+     had been reached.  Puts the character's `ucs4_t' representation in
+     `*PUC'.
+
+   The following functions determine the length of a Unicode string.
+
+ -- Function: size_t u8_strlen (const uint8_t *S)
+ -- Function: size_t u16_strlen (const uint16_t *S)
+ -- Function: size_t u32_strlen (const uint32_t *S)
+     Returns the number of units in S.
+
+     This function is similar to `strlen' and `wcslen', except that it
+     operates on Unicode strings.
+
+ -- Function: size_t u8_strnlen (const uint8_t *S, size_t MAXLEN)
+ -- Function: size_t u16_strnlen (const uint16_t *S, size_t MAXLEN)
+ -- Function: size_t u32_strnlen (const uint32_t *S, size_t MAXLEN)
+     Returns the number of units in S, but at most MAXLEN.
+
+     This function is similar to `strnlen' and `wcsnlen', except that
+     it operates on Unicode strings.
+
+   The following functions copy portions of Unicode strings in memory.
+
+ -- Function: uint8_t * u8_strcpy (uint8_t *DEST, const uint8_t *SRC)
+ -- Function: uint16_t * u16_strcpy (uint16_t *DEST, const uint16_t
+          *SRC)
+ -- Function: uint32_t * u32_strcpy (uint32_t *DEST, const uint32_t
+          *SRC)
+     Copies SRC to DEST.
+
+     This function is similar to `strcpy' and `wcscpy', except that it
+     operates on Unicode strings.
+
+ -- Function: uint8_t * u8_stpcpy (uint8_t *DEST, const uint8_t *SRC)
+ -- Function: uint16_t * u16_stpcpy (uint16_t *DEST, const uint16_t
+          *SRC)
+ -- Function: uint32_t * u32_stpcpy (uint32_t *DEST, const uint32_t
+          *SRC)
+     Copies SRC to DEST, returning the address of the terminating NUL
+     in DEST.
+
+     This function is similar to `stpcpy', except that it operates on
+     Unicode strings.
+
+ -- Function: uint8_t * u8_strncpy (uint8_t *DEST, const uint8_t *SRC,
+          size_t N)
+ -- Function: uint16_t * u16_strncpy (uint16_t *DEST, const uint16_t
+          *SRC, size_t N)
+ -- Function: uint32_t * u32_strncpy (uint32_t *DEST, const uint32_t
+          *SRC, size_t N)
+     Copies no more than N units of SRC to DEST.
+
+     This function is similar to `strncpy' and `wcsncpy', except that
+     it operates on Unicode strings.
+
+ -- Function: uint8_t * u8_stpncpy (uint8_t *DEST, const uint8_t *SRC,
+          size_t N)
+ -- Function: uint16_t * u16_stpncpy (uint16_t *DEST, const uint16_t
+          *SRC, size_t N)
+ -- Function: uint32_t * u32_stpncpy (uint32_t *DEST, const uint32_t
+          *SRC, size_t N)
+     Copies no more than N units of SRC to DEST, returning the address
+     of the last unit written into DEST.
+
+     This function is similar to `stpncpy', except that it operates on
+     Unicode strings.
+
+ -- Function: uint8_t * u8_strcat (uint8_t *DEST, const uint8_t *SRC)
+ -- Function: uint16_t * u16_strcat (uint16_t *DEST, const uint16_t
+          *SRC)
+ -- Function: uint32_t * u32_strcat (uint32_t *DEST, const uint32_t
+          *SRC)
+     Appends SRC onto DEST.
+
+     This function is similar to `strcat' and `wcscat', except that it
+     operates on Unicode strings.
+
+ -- Function: uint8_t * u8_strncat (uint8_t *DEST, const uint8_t *SRC,
+          size_t N)
+ -- Function: uint16_t * u16_strncat (uint16_t *DEST, const uint16_t
+          *SRC, size_t N)
+ -- Function: uint32_t * u32_strncat (uint32_t *DEST, const uint32_t
+          *SRC, size_t N)
+     Appends no more than N units of SRC onto DEST.
+
+     This function is similar to `strncat' and `wcsncat', except that
+     it operates on Unicode strings.
+
+   The following functions compare two Unicode strings.
+
+ -- Function: int u8_strcmp (const uint8_t *S1, const uint8_t *S2)
+ -- Function: int u16_strcmp (const uint16_t *S1, const uint16_t *S2)
+ -- Function: int u32_strcmp (const uint32_t *S1, const uint32_t *S2)
+     Compares S1 and S2, lexicographically.  Returns a negative value
+     if S1 compares smaller than S2, a positive value if S1 compares
+     larger than S2, or 0 if they compare equal.
+
+     This function is similar to `strcmp' and `wcscmp', except that it
+     operates on Unicode strings.
+
+ -- Function: int u8_strcoll (const uint8_t *S1, const uint8_t *S2)
+ -- Function: int u16_strcoll (const uint16_t *S1, const uint16_t *S2)
+ -- Function: int u32_strcoll (const uint32_t *S1, const uint32_t *S2)
+     Compares S1 and S2 using the collation rules of the current locale.
+     Returns -1 if S1 < S2, 0 if S1 = S2, 1 if S1 > S2.  Upon failure,
+     sets `errno' and returns any value.
+
+     This function is similar to `strcoll' and `wcscoll', except that
+     it operates on Unicode strings.
+
+     Note that this function may consider different canonical
+     normalizations of the same string as having a large distance.  It
+     is therefore better to use the function `u8_normcoll' instead of
+     this one; see *note uninorm.h::.
+
+ -- Function: int u8_strncmp (const uint8_t *S1, const uint8_t *S2,
+          size_t N)
+ -- Function: int u16_strncmp (const uint16_t *S1, const uint16_t *S2,
+          size_t N)
+ -- Function: int u32_strncmp (const uint32_t *S1, const uint32_t *S2,
+          size_t N)
+     Compares no more than N units of S1 and S2.
+
+     This function is similar to `strncmp' and `wcsncmp', except that
+     it operates on Unicode strings.
+
+   The following function allocates a duplicate of a Unicode string.
+
+ -- Function: uint8_t * u8_strdup (const uint8_t *S)
+ -- Function: uint16_t * u16_strdup (const uint16_t *S)
+ -- Function: uint32_t * u32_strdup (const uint32_t *S)
+     Duplicates S, returning an identical malloc'd string.
+
+     This function is similar to `strdup' and `wcsdup', except that it
+     operates on Unicode strings.
+
+   The following functions search for a given Unicode character.
+
+ -- Function: uint8_t * u8_strchr (const uint8_t *STR, ucs4_t UC)
+ -- Function: uint16_t * u16_strchr (const uint16_t *STR, ucs4_t UC)
+ -- Function: uint32_t * u32_strchr (const uint32_t *STR, ucs4_t UC)
+     Finds the first occurrence of UC in STR.
+
+     This function is similar to `strchr' and `wcschr', except that it
+     operates on Unicode strings.
+
+ -- Function: uint8_t * u8_strrchr (const uint8_t *STR, ucs4_t UC)
+ -- Function: uint16_t * u16_strrchr (const uint16_t *STR, ucs4_t UC)
+ -- Function: uint32_t * u32_strrchr (const uint32_t *STR, ucs4_t UC)
+     Finds the last occurrence of UC in STR.
+
+     This function is similar to `strrchr' and `wcsrchr', except that
+     it operates on Unicode strings.
+
+   The following functions search for the first occurrence of some
+Unicode character in or outside a given set of Unicode characters.
+
+ -- Function: size_t u8_strcspn (const uint8_t *STR, const uint8_t
+          *REJECT)
+ -- Function: size_t u16_strcspn (const uint16_t *STR, const uint16_t
+          *REJECT)
+ -- Function: size_t u32_strcspn (const uint32_t *STR, const uint32_t
+          *REJECT)
+     Returns the length of the initial segment of STR which consists
+     entirely of Unicode characters not in REJECT.
+
+     This function is similar to `strcspn' and `wcscspn', except that
+     it operates on Unicode strings.
+
+ -- Function: size_t u8_strspn (const uint8_t *STR, const uint8_t
+          *ACCEPT)
+ -- Function: size_t u16_strspn (const uint16_t *STR, const uint16_t
+          *ACCEPT)
+ -- Function: size_t u32_strspn (const uint32_t *STR, const uint32_t
+          *ACCEPT)
+     Returns the length of the initial segment of STR which consists
+     entirely of Unicode characters in ACCEPT.
+
+     This function is similar to `strspn' and `wcsspn', except that it
+     operates on Unicode strings.
+
+ -- Function: uint8_t * u8_strpbrk (const uint8_t *STR, const uint8_t
+          *ACCEPT)
+ -- Function: uint16_t * u16_strpbrk (const uint16_t *STR, const
+          uint16_t *ACCEPT)
+ -- Function: uint32_t * u32_strpbrk (const uint32_t *STR, const
+          uint32_t *ACCEPT)
+     Finds the first occurrence in STR of any character in ACCEPT.
+
+     This function is similar to `strpbrk' and `wcspbrk', except that
+     it operates on Unicode strings.
+
+   The following functions search whether a given Unicode string is a
+substring of another Unicode string.
+
+ -- Function: uint8_t * u8_strstr (const uint8_t *HAYSTACK, const
+          uint8_t *NEEDLE)
+ -- Function: uint16_t * u16_strstr (const uint16_t *HAYSTACK, const
+          uint16_t *NEEDLE)
+ -- Function: uint32_t * u32_strstr (const uint32_t *HAYSTACK, const
+          uint32_t *NEEDLE)
+     Finds the first occurrence of NEEDLE in HAYSTACK.
+
+     This function is similar to `strstr' and `wcsstr', except that it
+     operates on Unicode strings.
+
+ -- Function: bool u8_startswith (const uint8_t *STR, const uint8_t
+          *PREFIX)
+ -- Function: bool u16_startswith (const uint16_t *STR, const uint16_t
+          *PREFIX)
+ -- Function: bool u32_startswith (const uint32_t *STR, const uint32_t
+          *PREFIX)
+     Tests whether STR starts with PREFIX.
+
+ -- Function: bool u8_endswith (const uint8_t *STR, const uint8_t
+          *SUFFIX)
+ -- Function: bool u16_endswith (const uint16_t *STR, const uint16_t
+          *SUFFIX)
+ -- Function: bool u32_endswith (const uint32_t *STR, const uint32_t
+          *SUFFIX)
+     Tests whether STR ends with SUFFIX.
+
+   The following function does one step in tokenizing a Unicode string.
+
+ -- Function: uint8_t * u8_strtok (uint8_t *STR, const uint8_t *DELIM,
+          uint8_t **PTR)
+ -- Function: uint16_t * u16_strtok (uint16_t *STR, const uint16_t
+          *DELIM, uint16_t **PTR)
+ -- Function: uint32_t * u32_strtok (uint32_t *STR, const uint32_t
+          *DELIM, uint32_t **PTR)
+     Divides STR into tokens separated by characters in DELIM.
+
+     This function is similar to `strtok_r' and `wcstok', except that
+     it operates on Unicode strings.  Its interface is actually more
+     similar to `wcstok' than to `strtok'.
+
+
+File: libunistring.info,  Node: uniconv.h,  Next: unistdio.h,  Prev: unistr.h,  Up: Top
+
+5 Conversions between Unicode and encodings `<uniconv.h>'
+*********************************************************
+
+   This include file declares functions for converting between Unicode
+strings and `char *' strings in locale encoding or in other specified
+encodings.
+
+   The following function returns the locale encoding.
+
+ -- Function: const char * locale_charset ()
+     Determines the current locale's character encoding, and
+     canonicalizes it into one of the canonical names listed in
+     `config.charset'.  If the canonical name cannot be determined, the
+     result is a non-canonical name.
+
+     The result must not be freed; it is statically allocated.
+
+     The result of this function can be used as an argument to the
+     `iconv_open' function in GNU libc, in GNU libiconv, or in the
+     gnulib provided wrapper around the native `iconv_open' function.
+     It may not work as an argument to the native `iconv_open' function
+     directly.
+
+   The handling of unconvertible characters during the conversions can
+be parametrized through the following enumeration type:
+
+ -- Type: enum iconv_ilseq_handler
+     This type specifies how unconvertible characters in the input are
+     handled.
+
+ -- Constant: enum iconv_ilseq_handler iconveh_error
+     This handler causes the function to return with `errno' set to
+     `EILSEQ'.
+
+ -- Constant: enum iconv_ilseq_handler iconveh_question_mark
+     This handler produces one question mark `?' per unconvertible
+     character.
+
+ -- Constant: enum iconv_ilseq_handler iconveh_escape_sequence
+     This handler produces an escape sequence `\uXXXX' or `\UXXXXXXXX'
+     for each unconvertible character.
+
+   The following functions convert between strings in a specified
+encoding and Unicode strings.
+
+ -- Function: uint8_t * u8_conv_from_encoding (const char *FROMCODE,
+          enum iconv_ilseq_handler HANDLER, const char *SRC, size_t
+          SRCLEN, size_t *OFFSETS, uint8_t *RESULTBUF, size_t *LENGTHP)
+ -- Function: uint16_t * u16_conv_from_encoding (const char *FROMCODE,
+          enum iconv_ilseq_handler HANDLER, const char *SRC, size_t
+          SRCLEN, size_t *OFFSETS, uint16_t *RESULTBUF, size_t *LENGTHP)
+ -- Function: uint32_t * u32_conv_from_encoding (const char *FROMCODE,
+          enum iconv_ilseq_handler HANDLER, const char *SRC, size_t
+          SRCLEN, size_t *OFFSETS, uint32_t *RESULTBUF, size_t *LENGTHP)
+     Converts an entire string, possibly including NUL bytes, from one
+     encoding to UTF-8 encoding.
+
+     Converts a memory region given in encoding FROMCODE.  FROMCODE is
+     as for the `iconv_open' function.
+
+     The input is in the memory region between SRC (inclusive) and `SRC
+     + SRCLEN' (exclusive).
+
+     If OFFSETS is not NULL, it should point to an array of SRCLEN
+     integers; this array is filled with offsets into the result, i.e.
+     the character starting at `SRC[i]' corresponds to the character
+     starting at `RESULT[OFFSETS[i]]', and other offsets are set to
+     `(size_t)(-1)'.
+
+     `RESULTBUF' and `*LENGTHP' should be a scratch buffer and its
+     size, or `RESULTBUF' can be NULL.
+
+     May erase the contents of the memory at `RESULTBUF'.
+
+     If successful: The resulting Unicode string (non-NULL) is returned
+     and its length stored in `*LENGTHP'.  The resulting string is
+     `RESULTBUF' if no dynamic memory allocation was necessary, or a
+     freshly allocated memory block otherwise.
+
+     In case of error: NULL is returned and `errno' is set.  Particular
+     `errno' values: `EINVAL', `EILSEQ', `ENOMEM'.
+
+ -- Function: char * u8_conv_to_encoding (const char *TOCODE, enum
+          iconv_ilseq_handler HANDLER, const uint8_t *SRC, size_t
+          SRCLEN, size_t *OFFSETS, char *RESULTBUF, size_t *LENGTHP)
+ -- Function: char * u16_conv_to_encoding (const char *TOCODE, enum
+          iconv_ilseq_handler HANDLER, const uint16_t *SRC, size_t
+          SRCLEN, size_t *OFFSETS, char *RESULTBUF, size_t *LENGTHP)
+ -- Function: char * u32_conv_to_encoding (const char *TOCODE, enum
+          iconv_ilseq_handler HANDLER, const uint32_t *SRC, size_t
+          SRCLEN, size_t *OFFSETS, char *RESULTBUF, size_t *LENGTHP)
+     Converts an entire Unicode string, possibly including NUL units,
+     from UTF-8 encoding to a given encoding.
+
+     Converts a memory region to encoding TOCODE.  TOCODE is as for the
+     `iconv_open' function.
+
+     The input is in the memory region between SRC (inclusive) and `SRC
+     + SRCLEN' (exclusive).
+
+     If OFFSETS is not NULL, it should point to an array of SRCLEN
+     integers; this array is filled with offsets into the result, i.e.
+     the character starting at `SRC[i]' corresponds to the character
+     starting at `RESULT[OFFSETS[i]]', and other offsets are set to
+     `(size_t)(-1)'.
+
+     `RESULTBUF' and `*LENGTHP' should be a scratch buffer and its
+     size, or `RESULTBUF' can be NULL.
+
+     May erase the contents of the memory at `RESULTBUF'.
+
+     If successful: The resulting Unicode string (non-NULL) is returned
+     and its length stored in `*LENGTHP'.  The resulting string is
+     `RESULTBUF' if no dynamic memory allocation was necessary, or a
+     freshly allocated memory block otherwise.
+
+     In case of error: NULL is returned and `errno' is set.  Particular
+     `errno' values: `EINVAL', `EILSEQ', `ENOMEM'.
+
+   The following functions convert between NUL terminated strings in a
+specified encoding and NUL terminated Unicode strings.
+
+ -- Function: uint8_t * u8_strconv_from_encoding (const char *STRING,
+          const char *FROMCODE, enum iconv_ilseq_handler HANDLER)
+ -- Function: uint16_t * u16_strconv_from_encoding (const char *STRING,
+          const char *FROMCODE, enum iconv_ilseq_handler HANDLER)
+ -- Function: uint32_t * u32_strconv_from_encoding (const char *STRING,
+          const char *FROMCODE, enum iconv_ilseq_handler HANDLER)
+     Converts a NUL terminated string from a given encoding.
+
+     The result is `malloc' allocated, or NULL (with ERRNO set) in case
+     of error.
+
+     Particular `errno' values: `EILSEQ', `ENOMEM'.
+
+ -- Function: char * u8_strconv_to_encoding (const uint8_t *STRING,
+          const char *TOCODE, enum iconv_ilseq_handler HANDLER)
+ -- Function: char * u16_strconv_to_encoding (const uint16_t *STRING,
+          const char *TOCODE, enum iconv_ilseq_handler HANDLER)
+ -- Function: char * u32_strconv_to_encoding (const uint32_t *STRING,
+          const char *TOCODE, enum iconv_ilseq_handler HANDLER)
+     Converts a NUL terminated string to a given encoding.
+
+     The result is `malloc' allocated, or NULL (with `errno' set) in
+     case of error.
+
+     Particular `errno' values: `EILSEQ', `ENOMEM'.
+
+   The following functions are shorthands that convert between NUL
+terminated strings in locale encoding and NUL terminated Unicode
+strings.
+
+ -- Function: uint8_t * u8_strconv_from_locale (const char *STRING)
+ -- Function: uint16_t * u16_strconv_from_locale (const char *STRING)
+ -- Function: uint32_t * u32_strconv_from_locale (const char *STRING)
+     Converts a NUL terminated string from the locale encoding.
+
+     The result is `malloc' allocated, or NULL (with `errno' set) in
+     case of error.
+
+     Particular `errno' values: `ENOMEM'.
+
+ -- Function: char * u8_strconv_to_locale (const uint8_t *STRING)
+ -- Function: char * u16_strconv_to_locale (const uint16_t *STRING)
+ -- Function: char * u32_strconv_to_locale (const uint32_t *STRING)
+     Converts a NUL terminated string to the locale encoding.
+
+     The result is `malloc' allocated, or NULL (with `errno' set) in
+     case of error.
+
+     Particular `errno' values: `ENOMEM'.
+
+
+File: libunistring.info,  Node: unistdio.h,  Next: uniname.h,  Prev: uniconv.h,  Up: Top
+
+6 Output with Unicode strings `<unistdio.h>'
+********************************************
+
+   This include file declares functions for doing formatted output with
+Unicode strings.  It defines a set of functions similar to `fprintf' and
+`sprintf', which are declared in `<stdio.h>'.
+
+   These functions work like the `printf' function family.  In the
+format string:
+   * The format directive `U' takes an UTF-8 string (`const uint8_t *').
+
+   * The format directive `lU' takes an UTF-16 string (`const uint16_t
+     *').
+
+   * The format directive `llU' takes an UTF-32 string (`const uint32_t
+     *').
+
+   A function name with an infix `v' indicates that a `va_list' is
+passed instead of multiple arguments.
+
+   The functions `*sprintf' have a BUF argument that is assumed to be
+large enough.  (_DANGEROUS!  Overflowing the buffer will crash the
+program._)
+
+   The functions `*snprintf' have a BUF argument that is assumed to be
+SIZE units large.  (_DANGEROUS!  The resulting string might be
+truncated in the middle of a multibyte character._)
+
+   The functions `*asprintf' have a RESULTP argument.  The result will
+be freshly allocated and stored in `*resultp'.
+
+   The functions `*asnprintf' have a (RESULTBUF, LENGTHP) argument
+pair.  If RESULTBUF is not NULL and the result fits into `*LENGTHP'
+units, it is put in RESULTBUF, and RESULTBUF is returned.  Otherwise, a
+freshly allocated string is returned.  In both cases, `*LENGTHP' is set
+to the length (number of units) of the returned string.  In case of
+error, NULL is returned and `errno' is set.
+
+   The following functions take an ASCII format string and return a
+result that is a `char *' string in locale encoding.
+
+ -- Function: int ulc_sprintf (char *BUF, const char *FORMAT, ...)
+
+ -- Function: int ulc_snprintf (char *BUF, size_t size, const char
+          *FORMAT, ...)
+
+ -- Function: int ulc_asprintf (char **RESULTP, const char *FORMAT, ...)
+
+ -- Function: char * ulc_asnprintf (char *RESULTBUF, size_t *LENGTHP,
+          const char *FORMAT, ...)
+
+ -- Function: int ulc_vsprintf (char *BUF, const char *FORMAT, va_list
+          AP)
+
+ -- Function: int ulc_vsnprintf (char *BUF, size_t size, const char
+          *FORMAT, va_list AP)
+
+ -- Function: int ulc_vasprintf (char **RESULTP, const char *FORMAT,
+          va_list AP)
+
+ -- Function: char * ulc_vasnprintf (char *RESULTBUF, size_t *LENGTHP,
+          const char *FORMAT, va_list AP)
+
+   The following functions take an ASCII format string and return a
+result in UTF-8 format.
+
+ -- Function: int u8_sprintf (uint8_t *BUF, const char *FORMAT, ...)
+
+ -- Function: int u8_snprintf (uint8_t *BUF, size_t SIZE, const char
+          *FORMAT, ...)
+
+ -- Function: int u8_asprintf (uint8_t **RESULTP, const char *FORMAT,
+          ...)
+
+ -- Function: uint8_t * u8_asnprintf (uint8_t *RESULTBUF, size_t
+          *LENGTHP, const char *FORMAT, ...)
+
+ -- Function: int u8_vsprintf (uint8_t *BUF, const char *FORMAT,
+          va_list ap)
+
+ -- Function: int u8_vsnprintf (uint8_t *BUF, size_t SIZE, const char
+          *FORMAT, va_list AP)
+
+ -- Function: int u8_vasprintf (uint8_t **RESULTP, const char *FORMAT,
+          va_list AP)
+
+ -- Function: uint8_t * u8_vasnprintf (uint8_t *resultbuf, size_t
+          *LENGTHP, const char *FORMAT, va_list AP)
+
+   The following functions take an UTF-8 format string and return a
+result in UTF-8 format.
+
+ -- Function: int u8_u8_sprintf (uint8_t *BUF, const uint8_t *FORMAT,
+          ...)
+
+ -- Function: int u8_u8_snprintf (uint8_t *BUF, size_t SIZE, const
+          uint8_t *FORMAT, ...)
+
+ -- Function: int u8_u8_asprintf (uint8_t **RESULTP, const uint8_t
+          *FORMAT, ...)
+
+ -- Function: uint8_t * u8_u8_asnprintf (uint8_t *resultbuf, size_t
+          *LENGTHP, const uint8_t *FORMAT, ...)
+
+ -- Function: int u8_u8_vsprintf (uint8_t *BUF, const uint8_t *FORMAT,
+          va_list AP)
+
+ -- Function: int u8_u8_vsnprintf (uint8_t *BUF, size_t SIZE, const
+          uint8_t *FORMAT, va_list AP)
+
+ -- Function: int u8_u8_vasprintf (uint8_t **RESULTP, const uint8_t
+          *FORMAT, va_list AP)
+
+ -- Function: uint8_t * u8_u8_vasnprintf (uint8_t *resultbuf, size_t
+          *LENGTHP, const uint8_t *FORMAT, va_list AP)
+
+   The following functions take an ASCII format string and return a
+result in UTF-16 format.
+
+ -- Function: int u16_sprintf (uint16_t *BUF, const char *FORMAT, ...)
+
+ -- Function: int u16_snprintf (uint16_t *BUF, size_t SIZE, const char
+          *FORMAT, ...)
+
+ -- Function: int u16_asprintf (uint16_t **RESULTP, const char *FORMAT,
+          ...)
+
+ -- Function: uint16_t * u16_asnprintf (uint16_t *RESULTBUF, size_t
+          *LENGTHP, const char *FORMAT, ...)
+
+ -- Function: int u16_vsprintf (uint16_t *BUF, const char *FORMAT,
+          va_list ap)
+
+ -- Function: int u16_vsnprintf (uint16_t *BUF, size_t SIZE, const char
+          *FORMAT, va_list AP)
+
+ -- Function: int u16_vasprintf (uint16_t **RESULTP, const char
+          *FORMAT, va_list AP)
+
+ -- Function: uint16_t * u16_vasnprintf (uint16_t *resultbuf, size_t
+          *LENGTHP, const char *FORMAT, va_list AP)
+
+   The following functions take an UTF-16 format string and return a
+result in UTF-16 format.
+
+ -- Function: int u16_u16_sprintf (uint16_t *BUF, const uint16_t
+          *FORMAT, ...)
+
+ -- Function: int u16_u16_snprintf (uint16_t *BUF, size_t SIZE, const
+          uint16_t *FORMAT, ...)
+
+ -- Function: int u16_u16_asprintf (uint16_t **RESULTP, const uint16_t
+          *FORMAT, ...)
+
+ -- Function: uint16_t * u16_u16_asnprintf (uint16_t *resultbuf, size_t
+          *LENGTHP, const uint16_t *FORMAT, ...)
+
+ -- Function: int u16_u16_vsprintf (uint16_t *BUF, const uint16_t
+          *FORMAT, va_list AP)
+
+ -- Function: int u16_u16_vsnprintf (uint16_t *BUF, size_t SIZE, const
+          uint16_t *FORMAT, va_list AP)
+
+ -- Function: int u16_u16_vasprintf (uint16_t **RESULTP, const uint16_t
+          *FORMAT, va_list AP)
+
+ -- Function: uint16_t * u16_u16_vasnprintf (uint16_t *resultbuf,
+          size_t *LENGTHP, const uint16_t *FORMAT, va_list AP)
+
+   The following functions take an ASCII format string and return a
+result in UTF-32 format.
+
+ -- Function: int u32_sprintf (uint32_t *BUF, const char *FORMAT, ...)
+
+ -- Function: int u32_snprintf (uint32_t *BUF, size_t SIZE, const char
+          *FORMAT, ...)
+
+ -- Function: int u32_asprintf (uint32_t **RESULTP, const char *FORMAT,
+          ...)
+
+ -- Function: uint32_t * u32_asnprintf (uint32_t *RESULTBUF, size_t
+          *LENGTHP, const char *FORMAT, ...)
+
+ -- Function: int u32_vsprintf (uint32_t *BUF, const char *FORMAT,
+          va_list ap)
+
+ -- Function: int u32_vsnprintf (uint32_t *BUF, size_t SIZE, const char
+          *FORMAT, va_list AP)
+
+ -- Function: int u32_vasprintf (uint32_t **RESULTP, const char
+          *FORMAT, va_list AP)
+
+ -- Function: uint32_t * u32_vasnprintf (uint32_t *resultbuf, size_t
+          *LENGTHP, const char *FORMAT, va_list AP)
+
+   The following functions take an UTF-32 format string and return a
+result in UTF-32 format.
+
+ -- Function: int u32_u32_sprintf (uint32_t *BUF, const uint32_t
+          *FORMAT, ...)
+
+ -- Function: int u32_u32_snprintf (uint32_t *BUF, size_t SIZE, const
+          uint32_t *FORMAT, ...)
+
+ -- Function: int u32_u32_asprintf (uint32_t **RESULTP, const uint32_t
+          *FORMAT, ...)
+
+ -- Function: uint32_t * u32_u32_asnprintf (uint32_t *resultbuf, size_t
+          *LENGTHP, const uint32_t *FORMAT, ...)
+
+ -- Function: int u32_u32_vsprintf (uint32_t *BUF, const uint32_t
+          *FORMAT, va_list AP)
+
+ -- Function: int u32_u32_vsnprintf (uint32_t *BUF, size_t SIZE, const
+          uint32_t *FORMAT, va_list AP)
+
+ -- Function: int u32_u32_vasprintf (uint32_t **RESULTP, const uint32_t
+          *FORMAT, va_list AP)
+
+ -- Function: uint32_t * u32_u32_vasnprintf (uint32_t *resultbuf,
+          size_t *LENGTHP, const uint32_t *FORMAT, va_list AP)
+
+   The following functions take an ASCII format string and produce
+output in locale encoding to a `FILE' stream.
+
+ -- Function: int ulc_fprintf (FILE *STREAM, const char *FORMAT, ...)
+
+ -- Function: int ulc_vfprintf (FILE *STREAM, const char *FORMAT,
+          va_list AP)
+
+
+File: libunistring.info,  Node: uniname.h,  Next: unictype.h,  Prev: unistdio.h,  Up: Top
+
+7 Names of Unicode characters `<uniname.h>'
+*******************************************
+
+   This include file implements the association between a Unicode
+character and its name.
+
+   The name of a Unicode character allows to distinguish it from other,
+similar looking characters.  For example, the character `x' has the name
+`"LATIN SMALL LETTER X"' and is therefore different from the character
+named `"MULTIPLICATION SIGN"'.
+
+ -- Macro: unsigned int UNINAME_MAX
+     This macro expands to a constant that is the required size of
+     buffer for a Unicode character name.
+
+ -- Function: char * unicode_character_name (ucs4_t UC, char *BUF)
+     Looks up the name of a Unicode character, in uppercase ASCII.  BUF
+     must point to a buffer, at least `UNINAME_MAX' bytes in size.
+     Returns the filled BUF, or NULL if the character does not have a
+     name.
+
+ -- Function: ucs4_t unicode_name_character (const char *NAME)
+     Looks up the Unicode character with a given name, in upper- or
+     lowercase ASCII.  Returns the character if found, or
+     `UNINAME_INVALID' if not found.
+
+ -- Macro: ucs4_t UNINAME_INVALID
+     This macro expands to a constant that is a special return value of
+     the `unicode_name_character' function.
+
+
+File: libunistring.info,  Node: unictype.h,  Next: uniwidth.h,  Prev: uniname.h,  Up: Top
+
+8 Unicode character classification and properties `<unictype.h>'
+****************************************************************
+
+   This include file declares functions that classify Unicode characters
+and that test whether Unicode characters have specific properties.
+
+   The classification assigns a "general category" to every Unicode
+character.  This is similar to the classification provided by ISO C in
+`<wctype.h>'.
+
+   Properties are the data that guides various text processing
+algorithms in the presence of specific Unicode characters.
+
+* Menu:
+
+* General category::
+* Canonical combining class::
+* Bidirectional category::
+* Decimal digit value::
+* Digit value::
+* Numeric value::
+* Mirrored character::
+* Properties::
+* Scripts::
+* Blocks::
+* ISO C and Java syntax::
+* Classifications like in ISO C::
+
+
+File: libunistring.info,  Node: General category,  Next: Canonical combining class,  Up: unictype.h
+
+8.1 General category
+====================
+
+   Every Unicode character or code point has a _general category_
+assigned to it.  This classification is important for most algorithms
+that work on Unicode text.
+
+   The GNU libunistring library provides two kinds of API for working
+with general categories.  The object oriented API uses a variable to
+denote every predefined general category value or combinations thereof.
+The low-level API uses a bit mask instead.  The advantage of the object
+oriented API is that if only a few predefined general category values
+are used, the data tables are relatively small.  When you combine
+general category values (using `uc_general_category_or',
+`uc_general_category_and', or `uc_general_category_and_not'), or when
+you use the low level bit masks, a big table is used thats holds the
+complete general category information for all Unicode characters.
+
+* Menu:
+
+* Object oriented API::
+* Bit mask API::
+
+
+File: libunistring.info,  Node: Object oriented API,  Next: Bit mask API,  Up: General category
+
+8.1.1 The object oriented API for general category
+--------------------------------------------------
+
+ -- Type: uc_general_category_t
+     This data type denotes a general category value.  It is an
+     immediate type that can be copied by simple assignment, without
+     involving memory allocation.  It is not an array type.
+
+   The following are the predefined general category value.  Additional
+general categories may be added in the future.
+
+ -- Constant: uc_general_category_t UC_CATEGORY_L
+ -- Constant: uc_general_category_t UC_CATEGORY_Lu
+ -- Constant: uc_general_category_t UC_CATEGORY_Ll
+ -- Constant: uc_general_category_t UC_CATEGORY_Lt
+ -- Constant: uc_general_category_t UC_CATEGORY_Lm
+ -- Constant: uc_general_category_t UC_CATEGORY_Lo
+ -- Constant: uc_general_category_t UC_CATEGORY_M
+ -- Constant: uc_general_category_t UC_CATEGORY_Mn
+ -- Constant: uc_general_category_t UC_CATEGORY_Mc
+ -- Constant: uc_general_category_t UC_CATEGORY_Me
+ -- Constant: uc_general_category_t UC_CATEGORY_N
+ -- Constant: uc_general_category_t UC_CATEGORY_Nd
+ -- Constant: uc_general_category_t UC_CATEGORY_Nl
+ -- Constant: uc_general_category_t UC_CATEGORY_No
+ -- Constant: uc_general_category_t UC_CATEGORY_P
+ -- Constant: uc_general_category_t UC_CATEGORY_Pc
+ -- Constant: uc_general_category_t UC_CATEGORY_Pd
+ -- Constant: uc_general_category_t UC_CATEGORY_Ps
+ -- Constant: uc_general_category_t UC_CATEGORY_Pe
+ -- Constant: uc_general_category_t UC_CATEGORY_Pi
+ -- Constant: uc_general_category_t UC_CATEGORY_Pf
+ -- Constant: uc_general_category_t UC_CATEGORY_Po
+ -- Constant: uc_general_category_t UC_CATEGORY_S
+ -- Constant: uc_general_category_t UC_CATEGORY_Sm
+ -- Constant: uc_general_category_t UC_CATEGORY_Sc
+ -- Constant: uc_general_category_t UC_CATEGORY_Sk
+ -- Constant: uc_general_category_t UC_CATEGORY_So
+ -- Constant: uc_general_category_t UC_CATEGORY_Z
+ -- Constant: uc_general_category_t UC_CATEGORY_Zs
+ -- Constant: uc_general_category_t UC_CATEGORY_Zl
+ -- Constant: uc_general_category_t UC_CATEGORY_Zp
+ -- Constant: uc_general_category_t UC_CATEGORY_C
+ -- Constant: uc_general_category_t UC_CATEGORY_Cc
+ -- Constant: uc_general_category_t UC_CATEGORY_Cf
+ -- Constant: uc_general_category_t UC_CATEGORY_Cs
+ -- Constant: uc_general_category_t UC_CATEGORY_Co
+ -- Constant: uc_general_category_t UC_CATEGORY_Cn
+
+   The following are alias names for predefined General category values.
+
+ -- Macro: uc_general_category_t UC_LETTER
+     This is another name for `UC_CATEGORY_L'.
+
+ -- Macro: uc_general_category_t UC_UPPERCASE_LETTER
+     This is another name for `UC_CATEGORY_Lu'.
+
+ -- Macro: uc_general_category_t UC_LOWERCASE_LETTER
+     This is another name for `UC_CATEGORY_Ll'.
+
+ -- Macro: uc_general_category_t UC_TITLECASE_LETTER
+     This is another name for `UC_CATEGORY_Lt'.
+
+ -- Macro: uc_general_category_t UC_MODIFIER_LETTER
+     This is another name for `UC_CATEGORY_Lm'.
+
+ -- Macro: uc_general_category_t UC_OTHER_LETTER
+     This is another name for `UC_CATEGORY_Lo'.
+
+ -- Macro: uc_general_category_t UC_MARK
+     This is another name for `UC_CATEGORY_M'.
+
+ -- Macro: uc_general_category_t UC_NON_SPACING_MARK
+     This is another name for `UC_CATEGORY_Mn'.
+
+ -- Macro: uc_general_category_t UC_COMBINING_SPACING_MARK
+     This is another name for `UC_CATEGORY_Mc'.
+
+ -- Macro: uc_general_category_t UC_ENCLOSING_MARK
+     This is another name for `UC_CATEGORY_Me'.
+
+ -- Macro: uc_general_category_t UC_NUMBER
+     This is another name for `UC_CATEGORY_N'.
+
+ -- Macro: uc_general_category_t UC_DECIMAL_DIGIT_NUMBER
+     This is another name for `UC_CATEGORY_Nd'.
+
+ -- Macro: uc_general_category_t UC_LETTER_NUMBER
+     This is another name for `UC_CATEGORY_Nl'.
+
+ -- Macro: uc_general_category_t UC_OTHER_NUMBER
+     This is another name for `UC_CATEGORY_No'.
+
+ -- Macro: uc_general_category_t UC_PUNCTUATION
+     This is another name for `UC_CATEGORY_P'.
+
+ -- Macro: uc_general_category_t UC_CONNECTOR_PUNCTUATION
+     This is another name for `UC_CATEGORY_Pc'.
+
+ -- Macro: uc_general_category_t UC_DASH_PUNCTUATION
+     This is another name for `UC_CATEGORY_Pd'.
+
+ -- Macro: uc_general_category_t UC_OPEN_PUNCTUATION
+     This is another name for `UC_CATEGORY_Ps' ("start punctuation").
+
+ -- Macro: uc_general_category_t UC_CLOSE_PUNCTUATION
+     This is another name for `UC_CATEGORY_Pe' ("end punctuation").
+
+ -- Macro: uc_general_category_t UC_INITIAL_QUOTE_PUNCTUATION
+     This is another name for `UC_CATEGORY_Pi'.
+
+ -- Macro: uc_general_category_t UC_FINAL_QUOTE_PUNCTUATION
+     This is another name for `UC_CATEGORY_Pf'.
+
+ -- Macro: uc_general_category_t UC_OTHER_PUNCTUATION
+     This is another name for `UC_CATEGORY_Po'.
+
+ -- Macro: uc_general_category_t UC_SYMBOL
+     This is another name for `UC_CATEGORY_S'.
+
+ -- Macro: uc_general_category_t UC_MATH_SYMBOL
+     This is another name for `UC_CATEGORY_Sm'.
+
+ -- Macro: uc_general_category_t UC_CURRENCY_SYMBOL
+     This is another name for `UC_CATEGORY_Sc'.
+
+ -- Macro: uc_general_category_t UC_MODIFIER_SYMBOL
+     This is another name for `UC_CATEGORY_Sk'.
+
+ -- Macro: uc_general_category_t UC_OTHER_SYMBOL
+     This is another name for `UC_CATEGORY_So'.
+
+ -- Macro: uc_general_category_t UC_SEPARATOR
+     This is another name for `UC_CATEGORY_Z'.
+
+ -- Macro: uc_general_category_t UC_SPACE_SEPARATOR
+     This is another name for `UC_CATEGORY_Zs'.
+
+ -- Macro: uc_general_category_t UC_LINE_SEPARATOR
+     This is another name for `UC_CATEGORY_Zl'.
+
+ -- Macro: uc_general_category_t UC_PARAGRAPH_SEPARATOR
+     This is another name for `UC_CATEGORY_Zp'.
+
+ -- Macro: uc_general_category_t UC_OTHER
+     This is another name for `UC_CATEGORY_C'.
+
+ -- Macro: uc_general_category_t UC_CONTROL
+     This is another name for `UC_CATEGORY_Cc'.
+
+ -- Macro: uc_general_category_t UC_FORMAT
+     This is another name for `UC_CATEGORY_Cf'.
+
+ -- Macro: uc_general_category_t UC_SURROGATE
+     This is another name for `UC_CATEGORY_Cs'.  All code points in this
+     category are invalid characters.
+
+ -- Macro: uc_general_category_t UC_PRIVATE_USE
+     This is another name for `UC_CATEGORY_Co'.
+
+ -- Macro: uc_general_category_t UC_UNASSIGNED
+     This is another name for `UC_CATEGORY_Cn'.  Some code points in
+     this category are invalid characters.
+
+   The following functions combine general categories, like in a
+boolean algebra, except that there is no `not' operation.
+
+ -- Function: uc_general_category_t uc_general_category_or
+          (uc_general_category_t CATEGORY1, uc_general_category_t
+          CATEGORY2)
+     Returns the union of two general categories.  This corresponds to
+     the unions of the two sets of characters.
+
+ -- Function: uc_general_category_t uc_general_category_and
+          (uc_general_category_t CATEGORY1, uc_general_category_t
+          CATEGORY2)
+     Returns the intersection of two general categories as bit masks.
+     This _does not_ correspond to the intersection of the two sets of
+     characters.
+
+ -- Function: uc_general_category_t uc_general_category_and_not
+          (uc_general_category_t CATEGORY1, uc_general_category_t
+          CATEGORY2)
+     Returns the intersection of a general category with the complement
+     of a second general category, as bit masks.  This _does not_
+     correspond to the intersection with complement, when viewing the
+     categories as sets of characters.
+
+   The following functions associate general categories with their name.
+
+ -- Function: const char * uc_general_category_name
+          (uc_general_category_t CATEGORY)
+     Returns the name of a general category.  Returns NULL if the
+     general category corresponds to a bit mask that does not have a
+     name.
+
+ -- Function: uc_general_category_t uc_general_category_byname (const
+          char *CATEGORY_NAME)
+     Returns the general category given by name, e.g. `"Lu"'.
+
+   The following functions view general categories as sets of Unicode
+characters.
+
+ -- Function: uc_general_category_t uc_general_category (ucs4_t UC)
+     Returns the general category of a Unicode character.
+
+     This function uses a big table.
+
+ -- Function: bool uc_is_general_category (ucs4_t UC,
+          uc_general_category_t CATEGORY)
+     Tests whether a Unicode character belongs to a given category.
+     The CATEGORY argument can be a predefined general category or the
+     combination of several predefined general categories.
+
+
+File: libunistring.info,  Node: Bit mask API,  Prev: Object oriented API,  Up: General category
+
+8.1.2 The bit mask API for general category
+-------------------------------------------
+
+   The following are the predefined general category value as bit masks.
+Additional general categories may be added in the future.
+
+ -- Macro: uint32_t UC_CATEGORY_MASK_L
+ -- Macro: uint32_t UC_CATEGORY_MASK_Lu
+ -- Macro: uint32_t UC_CATEGORY_MASK_Ll
+ -- Macro: uint32_t UC_CATEGORY_MASK_Lt
+ -- Macro: uint32_t UC_CATEGORY_MASK_Lm
+ -- Macro: uint32_t UC_CATEGORY_MASK_Lo
+ -- Macro: uint32_t UC_CATEGORY_MASK_M
+ -- Macro: uint32_t UC_CATEGORY_MASK_Mn
+ -- Macro: uint32_t UC_CATEGORY_MASK_Mc
+ -- Macro: uint32_t UC_CATEGORY_MASK_Me
+ -- Macro: uint32_t UC_CATEGORY_MASK_N
+ -- Macro: uint32_t UC_CATEGORY_MASK_Nd
+ -- Macro: uint32_t UC_CATEGORY_MASK_Nl
+ -- Macro: uint32_t UC_CATEGORY_MASK_No
+ -- Macro: uint32_t UC_CATEGORY_MASK_P
+ -- Macro: uint32_t UC_CATEGORY_MASK_Pc
+ -- Macro: uint32_t UC_CATEGORY_MASK_Pd
+ -- Macro: uint32_t UC_CATEGORY_MASK_Ps
+ -- Macro: uint32_t UC_CATEGORY_MASK_Pe
+ -- Macro: uint32_t UC_CATEGORY_MASK_Pi
+ -- Macro: uint32_t UC_CATEGORY_MASK_Pf
+ -- Macro: uint32_t UC_CATEGORY_MASK_Po
+ -- Macro: uint32_t UC_CATEGORY_MASK_S
+ -- Macro: uint32_t UC_CATEGORY_MASK_Sm
+ -- Macro: uint32_t UC_CATEGORY_MASK_Sc
+ -- Macro: uint32_t UC_CATEGORY_MASK_Sk
+ -- Macro: uint32_t UC_CATEGORY_MASK_So
+ -- Macro: uint32_t UC_CATEGORY_MASK_Z
+ -- Macro: uint32_t UC_CATEGORY_MASK_Zs
+ -- Macro: uint32_t UC_CATEGORY_MASK_Zl
+ -- Macro: uint32_t UC_CATEGORY_MASK_Zp
+ -- Macro: uint32_t UC_CATEGORY_MASK_C
+ -- Macro: uint32_t UC_CATEGORY_MASK_Cc
+ -- Macro: uint32_t UC_CATEGORY_MASK_Cf
+ -- Macro: uint32_t UC_CATEGORY_MASK_Cs
+ -- Macro: uint32_t UC_CATEGORY_MASK_Co
+ -- Macro: uint32_t UC_CATEGORY_MASK_Cn
+
+   The following function views general categories as sets of Unicode
+characters.
+
+ -- Function: bool uc_is_general_category_withtable (ucs4_t UC,
+          uint32_t BITMASK)
+     Tests whether a Unicode character belongs to a given category.
+     The BITMASK argument can be a predefined general category bitmask
+     or the combination of several predefined general category bitmasks.
+
+     This function uses a big table comprising all general categories.
+
+
+File: libunistring.info,  Node: Canonical combining class,  Next: Bidirectional category,  Prev: General category,  Up: unictype.h
+
+8.2 Canonical combining class
+=============================
+
+   Every Unicode character or code point has a _canonical combining
+class_ assigned to it.
+
+   What is the meaning of the canonical combining class?  Essentially,
+it indicates the priority with which a combining character is attached
+to its base character.  The characters for which the canonical
+combining class is 0 are the base characters, and the characters for
+which it is greater than 0 are the combining characters.  Combining
+characters are rendered near/attached/around their base character, and
+combining characters with small combining classes are attached "first"
+or "closer" to the base character.
+
+   The canonical combining class of a character is a number in the range
+0..255.  The possible values are described in the Unicode Character
+Database `http://www.unicode.org/Public/UNIDATA/UCD.html'.  The list
+here is not definitive; more values can be added in future versions.
+
+ -- Constant: int UC_CCC_NR
+     The canonical combining class value for "Not Reordered" characters.
+     The value is 0.
+
+ -- Constant: int UC_CCC_OV
+     The canonical combining class value for "Overlay" characters.
+
+ -- Constant: int UC_CCC_NK
+     The canonical combining class value for "Nukta" characters.
+
+ -- Constant: int UC_CCC_KV
+     The canonical combining class value for "Kana Voicing" characters.
+
+ -- Constant: int UC_CCC_VR
+     The canonical combining class value for "Virama" characters.
+
+ -- Constant: int UC_CCC_ATBL
+     The canonical combining class value for "Attached Below Left"
+     characters.
+
+ -- Constant: int UC_CCC_ATB
+     The canonical combining class value for "Attached Below"
+     characters.
+
+ -- Constant: int UC_CCC_ATAR
+     The canonical combining class value for "Attached Above Right"
+     characters.
+
+ -- Constant: int UC_CCC_BL
+     The canonical combining class value for "Below Left" characters.
+
+ -- Constant: int UC_CCC_B
+     The canonical combining class value for "Below" characters.
+
+ -- Constant: int UC_CCC_BR
+     The canonical combining class value for "Below Right" characters.
+
+ -- Constant: int UC_CCC_L
+     The canonical combining class value for "Left" characters.
+
+ -- Constant: int UC_CCC_R
+     The canonical combining class value for "Right" characters.
+
+ -- Constant: int UC_CCC_AL
+     The canonical combining class value for "Above Left" characters.
+
+ -- Constant: int UC_CCC_A
+     The canonical combining class value for "Above" characters.
+
+ -- Constant: int UC_CCC_AR
+     The canonical combining class value for "Above Right" characters.
+
+ -- Constant: int UC_CCC_DB
+     The canonical combining class value for "Double Below" characters.
+
+ -- Constant: int UC_CCC_DA
+     The canonical combining class value for "Double Above" characters.
+
+ -- Constant: int UC_CCC_IS
+     The canonical combining class value for "Iota Subscript"
+     characters.
+
+   The following function looks up the canonical combining class of a
+character.
+
+ -- Function: int uc_combining_class (ucs4_t UC)
+     Returns the canonical combining class of a Unicode character.
+
+
+File: libunistring.info,  Node: Bidirectional category,  Next: Decimal digit value,  Prev: Canonical combining class,  Up: unictype.h
+
+8.3 Bidirectional category
+==========================
+
+   Every Unicode character or code point has a _bidirectional category_
+assigned to it.
+
+   The bidirectional category guides the bidirectional algorithm
+(`http://www.unicode.org/reports/tr9/').  The possible values are the
+following.
+
+ -- Constant: int UC_BIDI_L
+     The bidirectional category for `Left-to-Right`" characters.
+
+ -- Constant: int UC_BIDI_LRE
+     The bidirectional category for "Left-to-Right Embedding"
+     characters.
+
+ -- Constant: int UC_BIDI_LRO
+     The bidirectional category for "Left-to-Right Override" characters.
+
+ -- Constant: int UC_BIDI_R
+     The bidirectional category for "Right-to-Left" characters.
+
+ -- Constant: int UC_BIDI_AL
+     The bidirectional category for "Right-to-Left Arabic" characters.
+
+ -- Constant: int UC_BIDI_RLE
+     The bidirectional category for "Right-to-Left Embedding"
+     characters.
+
+ -- Constant: int UC_BIDI_RLO
+     The bidirectional category for "Right-to-Left Override" characters.
+
+ -- Constant: int UC_BIDI_PDF
+     The bidirectional category for "Pop Directional Format" characters.
+
+ -- Constant: int UC_BIDI_EN
+     The bidirectional category for "European Number" characters.
+
+ -- Constant: int UC_BIDI_ES
+     The bidirectional category for "European Number Separator"
+     characters.
+
+ -- Constant: int UC_BIDI_ET
+     The bidirectional category for "European Number Terminator"
+     characters.
+
+ -- Constant: int UC_BIDI_AN
+     The bidirectional category for "Arabic Number" characters.
+
+ -- Constant: int UC_BIDI_CS
+     The bidirectional category for "Common Number Separator"
+     characters.
+
+ -- Constant: int UC_BIDI_NSM
+     The bidirectional category for "Non-Spacing Mark" characters.
+
+ -- Constant: int UC_BIDI_BN
+     The bidirectional category for "Boundary Neutral" characters.
+
+ -- Constant: int UC_BIDI_B
+     The bidirectional category for "Paragraph Separator" characters.
+
+ -- Constant: int UC_BIDI_S
+     The bidirectional category for "Segment Separator" characters.
+
+ -- Constant: int UC_BIDI_WS
+     The bidirectional category for "Whitespace" characters.
+
+ -- Constant: int UC_BIDI_ON
+     The bidirectional category for "Other Neutral" characters.
+
+   The following functions implement the association between a
+bidirectional category and its name.
+
+ -- Function: const char * uc_bidi_category_name (int CATEGORY)
+     Returns the name of a bidirectional category.
+
+ -- Function: int uc_bidi_category_byname (const char *CATEGORY_NAME)
+     Returns the bidirectional category given by name, e.g. `"LRE"'.
+
+   The following functions view bidirectional categories as sets of
+Unicode characters.
+
+ -- Function: int uc_bidi_category (ucs4_t UC)
+     Returns the bidirectional category of a Unicode character.
+
+ -- Function: bool uc_is_bidi_category (ucs4_t UC, int CATEGORY)
+     Tests whether a Unicode character belongs to a given bidirectional
+     category.
+
+
+File: libunistring.info,  Node: Decimal digit value,  Next: Digit value,  Prev: Bidirectional category,  Up: unictype.h
+
+8.4 Decimal digit value
+=======================
+
+   Decimal digits (like the digits from `0' to `9') exist in many
+scripts.  The following function converts a decimal digit character to
+its numerical value.
+
+ -- Function: int uc_decimal_value (ucs4_t UC)
+     Returns the decimal digit value of a Unicode character.  The
+     return value is an integer in the range 0..9, or -1 for characters
+     that do not represent a decimal digit.
+
+
+File: libunistring.info,  Node: Digit value,  Next: Numeric value,  Prev: Decimal digit value,  Up: unictype.h
+
+8.5 Digit value
+===============
+
+   Digit characters are like decimal digit characters, possibly in
+special forms, like as superscript, subscript, or circled.  The
+following function converts a digit character to its numerical value.
+
+ -- Function: int uc_digit_value (ucs4_t UC)
+     Returns the digit value of a Unicode character.  The return value
+     is an integer in the range 0..9, or -1 for characters that do not
+     represent a digit.
+
+
+File: libunistring.info,  Node: Numeric value,  Next: Mirrored character,  Prev: Digit value,  Up: unictype.h
+
+8.6 Numeric value
+=================
+
+   There are also characters that represent numbers without a digit
+system, like the Roman numerals, and fractional numbers, like 1/4 or
+3/4.
+
+   The following type represents the numeric value of a Unicode
+character.
+
+ -- Type: uc_fraction_t
+     This is a structure type with the following fields:
+          int numerator;
+          int denominator;
+     An integer N is represented by `numerator = N', `denominator = 1'.
+
+   The following function converts a number character to its numerical
+value.
+
+ -- Function: uc_fraction_t uc_numeric_value (ucs4_t UC)
+     Returns the numeric value of a Unicode character.  The return
+     value is a fraction, or the pseudo-fraction `{ 0, 0 }' for
+     characters that do not represent a number.
+
+
+File: libunistring.info,  Node: Mirrored character,  Next: Properties,  Prev: Numeric value,  Up: unictype.h
+
+8.7 Mirrored character
+======================
+
+   Character mirroring is used to associate the closing parenthesis
+character to the opening parenthesis character, the closing brace
+character with the opening brace character, and so on.
+
+   The following function looks up the mirrored character of a Unicode
+character.
+
+ -- Function: bool uc_mirror_char (ucs4_t UC, ucs4_t *PUC)
+     Stores the mirrored character of a Unicode character UC in `*PUC'
+     and returns `true', if it exists.  Otherwise it stores UC
+     unmodified in `*PUC' and returns `false'.
+
+
+File: libunistring.info,  Node: Properties,  Next: Scripts,  Prev: Mirrored character,  Up: unictype.h
+
+8.8 Properties
+==============
+
+   This section defines boolean properties of Unicode characters.  This
+means, a character either has the given property or does not have it.
+In other words, the property can be viewed as a subset of the set of
+Unicode characters.
+
+   The GNU libunistring library provides two kinds of API for working
+with properties.  The object oriented API uses a type `uc_property_t'
+to designate a property.  In the function-based API, which is a bit more
+low level, a property is merely a function.
+
+* Menu:
+
+* Properties as objects::
+* Properties as functions::
+
+
+File: libunistring.info,  Node: Properties as objects,  Next: Properties as functions,  Up: Properties
+
+8.8.1 Properties as objects - the object oriented API
+-----------------------------------------------------
+
+   The following type designates a property on Unicode characters.
+
+ -- Type: uc_property_t
+     This data type denotes a boolean property on Unicode characters.
+     It is an immediate type that can be copied by simple assignment,
+     without involving memory allocation.  It is not an array type.
+
+   Many Unicode properties are predefined.
+
+   The following are general properties.
+
+ -- Constant: uc_property_t UC_PROPERTY_WHITE_SPACE
+ -- Constant: uc_property_t UC_PROPERTY_ALPHABETIC
+ -- Constant: uc_property_t UC_PROPERTY_OTHER_ALPHABETIC
+ -- Constant: uc_property_t UC_PROPERTY_NOT_A_CHARACTER
+ -- Constant: uc_property_t UC_PROPERTY_DEFAULT_IGNORABLE_CODE_POINT
+ -- Constant: uc_property_t
+UC_PROPERTY_OTHER_DEFAULT_IGNORABLE_CODE_POINT
+ -- Constant: uc_property_t UC_PROPERTY_DEPRECATED
+ -- Constant: uc_property_t UC_PROPERTY_LOGICAL_ORDER_EXCEPTION
+ -- Constant: uc_property_t UC_PROPERTY_VARIATION_SELECTOR
+ -- Constant: uc_property_t UC_PROPERTY_PRIVATE_USE
+ -- Constant: uc_property_t UC_PROPERTY_UNASSIGNED_CODE_VALUE
+
+   The following properties are related to case folding.
+
+ -- Constant: uc_property_t UC_PROPERTY_UPPERCASE
+ -- Constant: uc_property_t UC_PROPERTY_OTHER_UPPERCASE
+ -- Constant: uc_property_t UC_PROPERTY_LOWERCASE
+ -- Constant: uc_property_t UC_PROPERTY_OTHER_LOWERCASE
+ -- Constant: uc_property_t UC_PROPERTY_TITLECASE
+ -- Constant: uc_property_t UC_PROPERTY_SOFT_DOTTED
+
+   The following properties are related to identifiers.
+
+ -- Constant: uc_property_t UC_PROPERTY_ID_START
+ -- Constant: uc_property_t UC_PROPERTY_OTHER_ID_START
+ -- Constant: uc_property_t UC_PROPERTY_ID_CONTINUE
+ -- Constant: uc_property_t UC_PROPERTY_OTHER_ID_CONTINUE
+ -- Constant: uc_property_t UC_PROPERTY_XID_START
+ -- Constant: uc_property_t UC_PROPERTY_XID_CONTINUE
+ -- Constant: uc_property_t UC_PROPERTY_PATTERN_WHITE_SPACE
+ -- Constant: uc_property_t UC_PROPERTY_PATTERN_SYNTAX
+
+   The following properties have an influence on shaping and rendering.
+
+ -- Constant: uc_property_t UC_PROPERTY_JOIN_CONTROL
+ -- Constant: uc_property_t UC_PROPERTY_GRAPHEME_BASE
+ -- Constant: uc_property_t UC_PROPERTY_GRAPHEME_EXTEND
+ -- Constant: uc_property_t UC_PROPERTY_OTHER_GRAPHEME_EXTEND
+ -- Constant: uc_property_t UC_PROPERTY_GRAPHEME_LINK
+
+   The following properties relate to bidirectional reordering.
+
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_CONTROL
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_LEFT_TO_RIGHT
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_HEBREW_RIGHT_TO_LEFT
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_ARABIC_RIGHT_TO_LEFT
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_EUROPEAN_DIGIT
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_EUR_NUM_SEPARATOR
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_EUR_NUM_TERMINATOR
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_ARABIC_DIGIT
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_COMMON_SEPARATOR
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_BLOCK_SEPARATOR
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_SEGMENT_SEPARATOR
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_WHITESPACE
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_NON_SPACING_MARK
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_BOUNDARY_NEUTRAL
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_PDF
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_EMBEDDING_OR_OVERRIDE
+ -- Constant: uc_property_t UC_PROPERTY_BIDI_OTHER_NEUTRAL
+
+   The following properties deal with number representations.
+
+ -- Constant: uc_property_t UC_PROPERTY_HEX_DIGIT
+ -- Constant: uc_property_t UC_PROPERTY_ASCII_HEX_DIGIT
+
+   The following properties deal with CJK.
+
+ -- Constant: uc_property_t UC_PROPERTY_IDEOGRAPHIC
+ -- Constant: uc_property_t UC_PROPERTY_UNIFIED_IDEOGRAPH
+ -- Constant: uc_property_t UC_PROPERTY_RADICAL
+ -- Constant: uc_property_t UC_PROPERTY_IDS_BINARY_OPERATOR
+ -- Constant: uc_property_t UC_PROPERTY_IDS_TRINARY_OPERATOR
+
+   Other miscellaneous properties are:
+
+ -- Constant: uc_property_t UC_PROPERTY_ZERO_WIDTH
+ -- Constant: uc_property_t UC_PROPERTY_SPACE
+ -- Constant: uc_property_t UC_PROPERTY_NON_BREAK
+ -- Constant: uc_property_t UC_PROPERTY_ISO_CONTROL
+ -- Constant: uc_property_t UC_PROPERTY_FORMAT_CONTROL
+ -- Constant: uc_property_t UC_PROPERTY_DASH
+ -- Constant: uc_property_t UC_PROPERTY_HYPHEN
+ -- Constant: uc_property_t UC_PROPERTY_PUNCTUATION
+ -- Constant: uc_property_t UC_PROPERTY_LINE_SEPARATOR
+ -- Constant: uc_property_t UC_PROPERTY_PARAGRAPH_SEPARATOR
+ -- Constant: uc_property_t UC_PROPERTY_QUOTATION_MARK
+ -- Constant: uc_property_t UC_PROPERTY_SENTENCE_TERMINAL
+ -- Constant: uc_property_t UC_PROPERTY_TERMINAL_PUNCTUATION
+ -- Constant: uc_property_t UC_PROPERTY_CURRENCY_SYMBOL
+ -- Constant: uc_property_t UC_PROPERTY_MATH
+ -- Constant: uc_property_t UC_PROPERTY_OTHER_MATH
+ -- Constant: uc_property_t UC_PROPERTY_PAIRED_PUNCTUATION
+ -- Constant: uc_property_t UC_PROPERTY_LEFT_OF_PAIR
+ -- Constant: uc_property_t UC_PROPERTY_COMBINING
+ -- Constant: uc_property_t UC_PROPERTY_COMPOSITE
+ -- Constant: uc_property_t UC_PROPERTY_DECIMAL_DIGIT
+ -- Constant: uc_property_t UC_PROPERTY_NUMERIC
+ -- Constant: uc_property_t UC_PROPERTY_DIACRITIC
+ -- Constant: uc_property_t UC_PROPERTY_EXTENDER
+ -- Constant: uc_property_t UC_PROPERTY_IGNORABLE_CONTROL
+
+   The following function looks up a property by its name.
+
+ -- Function: uc_property_t uc_property_byname (const char
+          *PROPERTY_NAME)
+     Returns the property given by name, e.g. `"White space"'.  If a
+     property with the given name exists, the result will satisfy the
+     `uc_property_is_valid' predicate.  Otherwise the result will not
+     satisfy this predicate and must not be passed to functions that
+     expect an `uc_property_t' argument.
+
+     This function references a big table of all predefined properties.
+     Its use can significantly increase the size of your application.
+
+ -- Function: bool uc_property_is_valid (uc_property_t property)
+     Returns `true' when the given property is valid, or `false'
+     otherwise.
+
+   The following function views a property as a set of Unicode
+characters.
+
+ -- Function: bool uc_is_property (ucs4_t UC, uc_property_t PROPERTY)
+     Tests whether the Unicode character UC has the given property.
+
+
+File: libunistring.info,  Node: Properties as functions,  Prev: Properties as objects,  Up: Properties
+
+8.8.2 Properties as functions - the functional API
+--------------------------------------------------
+
+   The following are general properties.
+
+ -- Function: bool uc_is_property_white_space (ucs4_t UC)
+ -- Function: bool uc_is_property_alphabetic (ucs4_t UC)
+ -- Function: bool uc_is_property_other_alphabetic (ucs4_t UC)
+ -- Function: bool uc_is_property_not_a_character (ucs4_t UC)
+ -- Function: bool uc_is_property_default_ignorable_code_point (ucs4_t
+          UC)
+ -- Function: bool uc_is_property_other_default_ignorable_code_point
+          (ucs4_t UC)
+ -- Function: bool uc_is_property_deprecated (ucs4_t UC)
+ -- Function: bool uc_is_property_logical_order_exception (ucs4_t UC)
+ -- Function: bool uc_is_property_variation_selector (ucs4_t UC)
+ -- Function: bool uc_is_property_private_use (ucs4_t UC)
+ -- Function: bool uc_is_property_unassigned_code_value (ucs4_t UC)
+
+   The following properties are related to case folding.
+
+ -- Function: bool uc_is_property_uppercase (ucs4_t UC)
+ -- Function: bool uc_is_property_other_uppercase (ucs4_t UC)
+ -- Function: bool uc_is_property_lowercase (ucs4_t UC)
+ -- Function: bool uc_is_property_other_lowercase (ucs4_t UC)
+ -- Function: bool uc_is_property_titlecase (ucs4_t UC)
+ -- Function: bool uc_is_property_soft_dotted (ucs4_t UC)
+
+   The following properties are related to identifiers.
+
+ -- Function: bool uc_is_property_id_start (ucs4_t UC)
+ -- Function: bool uc_is_property_other_id_start (ucs4_t UC)
+ -- Function: bool uc_is_property_id_continue (ucs4_t UC)
+ -- Function: bool uc_is_property_other_id_continue (ucs4_t UC)
+ -- Function: bool uc_is_property_xid_start (ucs4_t UC)
+ -- Function: bool uc_is_property_xid_continue (ucs4_t UC)
+ -- Function: bool uc_is_property_pattern_white_space (ucs4_t UC)
+ -- Function: bool uc_is_property_pattern_syntax (ucs4_t UC)
+
+   The following properties have an influence on shaping and rendering.
+
+ -- Function: bool uc_is_property_join_control (ucs4_t UC)
+ -- Function: bool uc_is_property_grapheme_base (ucs4_t UC)
+ -- Function: bool uc_is_property_grapheme_extend (ucs4_t UC)
+ -- Function: bool uc_is_property_other_grapheme_extend (ucs4_t UC)
+ -- Function: bool uc_is_property_grapheme_link (ucs4_t UC)
+
+   The following properties relate to bidirectional reordering.
+
+ -- Function: bool uc_is_property_bidi_control (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_left_to_right (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_hebrew_right_to_left (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_arabic_right_to_left (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_european_digit (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_eur_num_separator (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_eur_num_terminator (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_arabic_digit (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_common_separator (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_block_separator (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_segment_separator (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_whitespace (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_non_spacing_mark (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_boundary_neutral (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_pdf (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_embedding_or_override (ucs4_t UC)
+ -- Function: bool uc_is_property_bidi_other_neutral (ucs4_t UC)
+
+   The following properties deal with number representations.
+
+ -- Function: bool uc_is_property_hex_digit (ucs4_t UC)
+ -- Function: bool uc_is_property_ascii_hex_digit (ucs4_t UC)
+
+   The following properties deal with CJK.
+
+ -- Function: bool uc_is_property_ideographic (ucs4_t UC)
+ -- Function: bool uc_is_property_unified_ideograph (ucs4_t UC)
+ -- Function: bool uc_is_property_radical (ucs4_t UC)
+ -- Function: bool uc_is_property_ids_binary_operator (ucs4_t UC)
+ -- Function: bool uc_is_property_ids_trinary_operator (ucs4_t UC)
+
+   Other miscellaneous properties are:
+
+ -- Function: bool uc_is_property_zero_width (ucs4_t UC)
+ -- Function: bool uc_is_property_space (ucs4_t UC)
+ -- Function: bool uc_is_property_non_break (ucs4_t UC)
+ -- Function: bool uc_is_property_iso_control (ucs4_t UC)
+ -- Function: bool uc_is_property_format_control (ucs4_t UC)
+ -- Function: bool uc_is_property_dash (ucs4_t UC)
+ -- Function: bool uc_is_property_hyphen (ucs4_t UC)
+ -- Function: bool uc_is_property_punctuation (ucs4_t UC)
+ -- Function: bool uc_is_property_line_separator (ucs4_t UC)
+ -- Function: bool uc_is_property_paragraph_separator (ucs4_t UC)
+ -- Function: bool uc_is_property_quotation_mark (ucs4_t UC)
+ -- Function: bool uc_is_property_sentence_terminal (ucs4_t UC)
+ -- Function: bool uc_is_property_terminal_punctuation (ucs4_t UC)
+ -- Function: bool uc_is_property_currency_symbol (ucs4_t UC)
+ -- Function: bool uc_is_property_math (ucs4_t UC)
+ -- Function: bool uc_is_property_other_math (ucs4_t UC)
+ -- Function: bool uc_is_property_paired_punctuation (ucs4_t UC)
+ -- Function: bool uc_is_property_left_of_pair (ucs4_t UC)
+ -- Function: bool uc_is_property_combining (ucs4_t UC)
+ -- Function: bool uc_is_property_composite (ucs4_t UC)
+ -- Function: bool uc_is_property_decimal_digit (ucs4_t UC)
+ -- Function: bool uc_is_property_numeric (ucs4_t UC)
+ -- Function: bool uc_is_property_diacritic (ucs4_t UC)
+ -- Function: bool uc_is_property_extender (ucs4_t UC)
+ -- Function: bool uc_is_property_ignorable_control (ucs4_t UC)
+
+
+File: libunistring.info,  Node: Scripts,  Next: Blocks,  Prev: Properties,  Up: unictype.h
+
+8.9 Scripts
+===========
+
+   The Unicode characters are subdivided into scripts.
+
+   The following type is used to represent a script:
+
+ -- Type: uc_script_t
+     This data type is a structure type that refers to statically
+     allocated read-only data.  It contains the following fields:
+          const char *name;
+
+     The `name' field contains the name of the script.
+
+   The following functions look up a script.
+
+ -- Function: const uc_script_t * uc_script (ucs4_t UC)
+     Returns the script of a Unicode character.  Returns NULL if UC
+     does not belong to any script.
+
+ -- Function: const uc_script_t * uc_script_byname (const char
+          *SCRIPT_NAME)
+     Returns the script given by its name, e.g. `"HAN"'.  Returns NULL
+     if a script with the given name does not exist.
+
+   The following function views a script as a set of Unicode characters.
+
+ -- Function: bool uc_is_script (ucs4_t UC, const uc_script_t *SCRIPT)
+     Tests whether a Unicode character belongs to a given script.
+
+   The following gives a global picture of all scripts.
+
+ -- Function: void uc_all_scripts (const uc_script_t **SCRIPTS, size_t
+          *COUNT)
+     Get the list of all scripts.  Stores a pointer to an array of all
+     scripts in `*SCRIPTS' and the length of this array in `*COUNT'.
+
+
+File: libunistring.info,  Node: Blocks,  Next: ISO C and Java syntax,  Prev: Scripts,  Up: unictype.h
+
+8.10 Blocks
+===========
+
+   The Unicode characters are subdivided into blocks.  A block is an
+interval of Unicode code points.
+
+   The following type is used to represent a block.
+
+ -- Type: uc_block_t
+     This data type is a structure type that refers to statically
+     allocated data.  It contains the following fields:
+          ucs4_t start;
+          ucs4_t end;
+          const char *name;
+
+     The `start' field is the first Unicode code point in the block.
+
+     The `end' field is the last Unicode code point in the block.
+
+     The `name' field is the name of the block.
+
+   The following function looks up a block.
+
+ -- Function: const uc_block_t * uc_block (ucs4_t UC)
+     Returns the block a character belongs to.
+
+   The following function views a block as a set of Unicode characters.
+
+ -- Function: bool uc_is_block (ucs4_t UC, const uc_block_t *BLOCK)
+     Tests whether a Unicode character belongs to a given block.
+
+   The following gives a global picture of all block.
+
+ -- Function: void uc_all_blocks (const uc_block_t **BLOCKS, size_t
+          *COUNT)
+     Get the list of all blocks.  Stores a pointer to an array of all
+     blocks in `*BLOCKS' and the length of this array in `*COUNT'.
+
+
+File: libunistring.info,  Node: ISO C and Java syntax,  Next: Classifications like in ISO C,  Prev: Blocks,  Up: unictype.h
+
+8.11 ISO C and Java syntax
+==========================
+
+   The following properties are taken from language standards.  The
+supported language standards are ISO C 99 and Java.
+
+ -- Function: bool uc_is_c_whitespace (ucs4_t UC)
+     Tests whether a Unicode character is considered whitespace in ISO
+     C 99.
+
+ -- Function: bool uc_is_java_whitespace (ucs4_t UC)
+     Tests whether a Unicode character is considered whitespace in Java.
+
+   The following enumerated values are the possible return values of
+the functions `uc_c_ident_category' and `uc_java_ident_category'.
+
+ -- Constant: int UC_IDENTIFIER_START
+     This return value means that the given character is valid as first
+     or subsequent character in an identifier.
+
+ -- Constant: int UC_IDENTIFIER_VALID
+     This return value means that the given character is valid as
+     subsequent character only.
+
+ -- Constant: int UC_IDENTIFIER_INVALID
+     This return value means that the given character is not valid in
+     an identifier.
+
+ -- Constant: int UC_IDENTIFIER_IGNORABLE
+     This return value (only for Java) means that the given character
+     is ignorable.
+
+   The following function determine whether a given character can be a
+constituent of an identifier in the given programming language.
+
+ -- Function: int uc_c_ident_category (ucs4_t UC)
+     Returns the categorization of a Unicode character with respect to
+     the ISO C 99 identifier syntax.
+
+ -- Function: int uc_java_ident_category (ucs4_t UC)
+     Returns the categorization of a Unicode character with respect to
+     the Java identifier syntax.
+
+
+File: libunistring.info,  Node: Classifications like in ISO C,  Prev: ISO C and Java syntax,  Up: unictype.h
+
+8.12 Classifications like in ISO C
+==================================
+
+   The following character classifications mimic those declared in the
+ISO C header files `<ctype.h>' and `<wctype.h>'.  These functions are
+deprecated, because this set of functions was designed with ASCII in
+mind and cannot reflect the more diverse reality of the Unicode
+character set.  But they can be a quick-and-dirty porting aid when
+migrating from `wchar_t' APIs to Unicode strings.
+
+ -- Function: bool uc_is_alnum (ucs4_t UC)
+     Tests for any character for which `uc_is_alpha' or `uc_is_digit' is
+     true.
+
+ -- Function: bool uc_is_alpha (ucs4_t UC)
+     Tests for any character for which `uc_is_upper' or `uc_is_lower' is
+     true, or any character that is one of a locale-specific set of
+     characters for which none of `uc_is_cntrl', `uc_is_digit',
+     `uc_is_punct', or `uc_is_space' is true.
+
+ -- Function: bool uc_is_cntrl (ucs4_t UC)
+     Tests for any control character.
+
+ -- Function: bool uc_is_digit (ucs4_t UC)
+     Tests for any character that corresponds to a decimal-digit
+     character.
+
+ -- Function: bool uc_is_graph (ucs4_t UC)
+     Tests for any character for which `uc_is_print' is true and
+     `uc_is_space' is false.
+
+ -- Function: bool uc_is_lower (ucs4_t UC)
+     Tests for any character that corresponds to a lowercase letter or
+     is one of a locale-specific set of characters for which none of
+     `uc_is_cntrl', `uc_is_digit', `uc_is_punct', or `uc_is_space' is
+     true.
+
+ -- Function: bool uc_is_print (ucs4_t UC)
+     Tests for any printing character.
+
+ -- Function: bool uc_is_punct (ucs4_t UC)
+     Tests for any printing character that is one of a locale-specific
+     set of characters for which neither `uc_is_space' nor
+     `uc_is_alnum' is true.
+
+ -- Function: bool uc_is_space (ucs4_t UC)
+     Test for any character that corresponds to a locale-specific set
+     of characters for which none of `uc_is_alnum', `uc_is_graph', or
+     `uc_is_punct' is true.
+
+ -- Function: bool uc_is_upper (ucs4_t UC)
+     Tests for any character that corresponds to an uppercase letter or
+     is one of a locale-specific set of characters for which none of
+     `uc_is_cntrl', `uc_is_digit', `uc_is_punct', or `uc_is_space' is
+     true.
+
+ -- Function: bool uc_is_xdigit (ucs4_t UC)
+     Tests for any character that corresponds to a hexadecimal-digit
+     character.
+
+ -- Function: bool uc_is_blank (ucs4_t UC)
+     Tests for any character that corresponds to a standard blank
+     character or a locale-specific set of characters for which
+     `uc_is_alnum' is false.
+
+
+File: libunistring.info,  Node: uniwidth.h,  Next: uniwbrk.h,  Prev: unictype.h,  Up: Top
+
+9 Display width `<uniwidth.h>'
+******************************
+
+   This include file declares functions that return the display width,
+measured in columns, of characters or strings, when output to a device
+that uses non-proportional fonts.
+
+   Note that for some rarely used characters the actual fonts or
+terminal emulators can use a different width.  There is no mechanism
+for communicating the display width of characters across a Unix
+pseudo-terminal (tty).  Also, there are scripts with complex rendering,
+like the Indic scripts.  For these scripts, there is no such concept as
+non-proportional fonts.  Therefore the results of these functions
+usually work fine on most scripts and on most characters but can fail
+to represent the actual display width.
+
+   These functions are locale dependent.  The ENCODING argument
+identifies the encoding (e.g. `"ISO-8859-2"' for Polish).
+
+ -- Function: int uc_width (ucs4_t UC, const char *ENCODING)
+     Determines and returns the number of column positions required for
+     UC.  Returns -1 if UC is a control character that has an influence
+     on the column position when output.
+
+ -- Function: int u8_width (const uint8_t *S, size_t N, const char
+          *ENCODING)
+ -- Function: int u16_width (const uint16_t *S, size_t N, const char
+          *ENCODING)
+ -- Function: int u32_width (const uint32_t *S, size_t N, const char
+          *ENCODING)
+     Determines and returns the number of column positions required for
+     first N units (or fewer if S ends before this) in S.  This
+     function ignores control characters in the string.
+
+ -- Function: int u8_strwidth (const uint8_t *S, const char *ENCODING)
+ -- Function: int u16_strwidth (const uint16_t *S, const char *ENCODING)
+ -- Function: int u32_strwidth (const uint32_t *S, const char *ENCODING)
+     Determines and returns the number of column positions required for
+     S.  This function ignores control characters in the string.
+
+
+File: libunistring.info,  Node: uniwbrk.h,  Next: unilbrk.h,  Prev: uniwidth.h,  Up: Top
+
+10 Word breaks in strings `<uniwbrk.h>'
+***************************************
+
+   This include file declares functions for determining where in a
+string "words" start and end.  Here "words" are not necessarily the
+same as entities that can be looked up in dictionaries, but rather
+groups of consecutive characters that should not be split by text
+processing operations.
+
+* Menu:
+
+* Word breaks in a string::
+* Word break property::
+
+
+File: libunistring.info,  Node: Word breaks in a string,  Next: Word break property,  Up: uniwbrk.h
+
+10.1 Word breaks in a string
+============================
+
+   The following functions determine the word breaks in a string.
+
+ -- Function: void u8_wordbreaks (const uint8_t *S, size_t N, char *P)
+ -- Function: void u16_wordbreaks (const uint16_t *S, size_t N, char *P)
+ -- Function: void u32_wordbreaks (const uint32_t *S, size_t N, char *P)
+ -- Function: void ulc_wordbreaks (const char *S, size_t N, char *P)
+     Determines the word break points in S, an array of N units, and
+     stores the result at `P[0..N-1]'.
+    `P[i] = 1'
+          means that there is a word boundary between `S[i-1]' and
+          `S[i]'.
+
+    `P[i] = 0'
+          means that `S[i-1]' and `S[i]' must not be separated.
+     `P[0]' is always set to 0.  If an application wants to consider a
+     word break to be present at the beginning of the string (before
+     `S[0]') or at the end of the string (after `S[0..N-1]'), it has to
+     treat these cases explicitly.
+
+
+File: libunistring.info,  Node: Word break property,  Prev: Word breaks in a string,  Up: uniwbrk.h
+
+10.2 Word break property
+========================
+
+   This is a more low-level API.  The word break property is a property
+defined in Unicode Standard Annex #29, section "Word Boundaries", see
+`http://www.unicode.org/reports/tr29/#Word_Boundaries'.  It is used for
+determining the word breaks in a string.
+
+   The following are the possible values of the word break property.
+More values may be added in the future.
+
+ -- Constant: int WBP_OTHER
+ -- Constant: int WBP_CR
+ -- Constant: int WBP_LF
+ -- Constant: int WBP_NEWLINE
+ -- Constant: int WBP_EXTEND
+ -- Constant: int WBP_FORMAT
+ -- Constant: int WBP_KATAKANA
+ -- Constant: int WBP_ALETTER
+ -- Constant: int WBP_MIDNUMLET
+ -- Constant: int WBP_MIDLETTER
+ -- Constant: int WBP_MIDNUM
+ -- Constant: int WBP_NUMERIC
+ -- Constant: int WBP_EXTENDNUMLET
+
+   The following function looks up the word break property of a
+character.
+
+ -- Function: int uc_wordbreak_property (ucs4_t UC)
+     Returns the Word_Break property of a Unicode character.
+
+
+File: libunistring.info,  Node: unilbrk.h,  Next: uninorm.h,  Prev: uniwbrk.h,  Up: Top
+
+11 Line breaking `<unilbrk.h>'
+******************************
+
+   This include file declares functions for determining where in a
+string line breaks could or should be introduced, in order to make the
+displayed string fit into a column of given width.
+
+   These functions are locale dependent.  The ENCODING argument
+identifies the encoding (e.g. `"ISO-8859-2"' for Polish).
+
+   The following enumerated values indicate whether, at a given
+position, a line break is possible or not.  Given an string S as an
+array `S[0..N-1]' and a position I, the values have the following
+meanings:
+
+ -- Constant: int UC_BREAK_MANDATORY
+     This value indicates that `S[I]' is a line break character.
+
+ -- Constant: int UC_BREAK_POSSIBLE
+     This value indicates that a line break may be inserted between
+     `S[I-1]' and `S[I]'.
+
+ -- Constant: int UC_BREAK_HYPHENATION
+     This value indicates that a hyphen and a line break may be
+     inserted between `S[I-1]' and `S[I]'.  But beware of language
+     dependent hyphenation rules.
+
+ -- Constant: int UC_BREAK_PROHIBITED
+     This value indicates that `S[I-1]' and `S[I]' must not be
+     separated.
+
+ -- Constant: int UC_BREAK_UNDEFINED
+     This value is not used as a return value; rather, in the
+     overriding argument of the `u*_width_linebreaks' functions, it
+     indicates the absence of an override.
+
+   The following functions determine the positions at which line breaks
+are possible.
+
+ -- Function: void u8_possible_linebreaks (const uint8_t *S, size_t N,
+          const char *ENCODING, char *P)
+ -- Function: void u16_possible_linebreaks (const uint16_t *S, size_t
+          N, const char *ENCODING, char *P)
+ -- Function: void u32_possible_linebreaks (const uint32_t *S, size_t
+          N, const char *ENCODING, char *P)
+ -- Function: void ulc_possible_linebreaks (const char *S, size_t N,
+          const char *ENCODING, char *P)
+     Determines the line break points in S, and stores the result at
+     `P[0..N-1]'.  Every `P[I]' is assigned one of the values
+     `UC_BREAK_MANDATORY', `UC_BREAK_POSSIBLE', `UC_BREAK_HYPHENATION',
+     `UC_BREAK_PROHIBITED'.
+
+   The following functions determine where line breaks should be
+inserted so that each line fits in a given width, when output to a
+device that uses non-proportional fonts.
+
+ -- Function: int u8_width_linebreaks (const uint8_t *S, size_t N, int
+          WIDTH, int START_COLUMN, int AT_END_COLUMNS, const char
+          *OVERRIDE, const char *ENCODING, char *P)
+ -- Function: int u16_width_linebreaks (const uint16_t *S, size_t N,
+          int WIDTH, int START_COLUMN, int AT_END_COLUMNS, const char
+          *OVERRIDE, const char *ENCODING, char *P)
+ -- Function: int u32_width_linebreaks (const uint32_t *S, size_t N,
+          int WIDTH, int START_COLUMN, int AT_END_COLUMNS, const char
+          *OVERRIDE, const char *ENCODING, char *P)
+ -- Function: int ulc_width_linebreaks (const char *S, size_t N, int
+          WIDTH, int START_COLUMN, int AT_END_COLUMNS, const char
+          *OVERRIDE, const char *ENCODING, char *P)
+     Chooses the best line breaks, assuming that every character
+     occupies a width given by the `uc_width' function (see *note
+     uniwidth.h::).
+
+     The string is `S[0..N-1]'.
+
+     The maximum number of columns per line is given as WIDTH.  The
+     starting column of the string is given as START_COLUMN.  If the
+     algorithm shall keep room after the last piece, this amount of
+     room can be given as AT_END_COLUMNS.
+
+     OVERRIDE is an optional override; if `OVERRIDE[I] !=
+     UC_BREAK_UNDEFINED', `OVERRIDE[I]' takes precedence over `P[I]' as
+     returned by the `u*_possible_linebreaks' function.
+
+     The given ENCODING is used for disambiguating widths in `uc_width'.
+
+     Returns the column after the end of the string, and stores the
+     result at `P[0..N-1]'.  Every `P[I]' is assigned one of the values
+     `UC_BREAK_MANDATORY', `UC_BREAK_POSSIBLE', `UC_BREAK_HYPHENATION',
+     `UC_BREAK_PROHIBITED'.  Here the value `UC_BREAK_POSSIBLE'
+     indicates that a line break _should_ be inserted.
+
+
+File: libunistring.info,  Node: uninorm.h,  Next: unicase.h,  Prev: unilbrk.h,  Up: Top
+
+12 Normalization forms (composition and decomposition) `<uninorm.h>'
+********************************************************************
+
+   This include file defines functions for transforming Unicode strings
+to one of the four normal forms, known as NFC, NFD, NKFC, NFKD.  These
+transformations involve decomposition and -- for NFC and NFKC --
+composition of Unicode characters.
+
+* Menu:
+
+* Decomposition of characters::
+* Composition of characters::
+* Normalization of strings::
+* Normalizing comparisons::
+* Normalization of streams::
+
+
+File: libunistring.info,  Node: Decomposition of characters,  Next: Composition of characters,  Up: uninorm.h
+
+12.1 Decomposition of Unicode characters
+========================================
+
+   The following enumerated values are the possible types of
+decomposition of a Unicode character.
+
+ -- Constant: int UC_DECOMP_CANONICAL
+     Denotes canonical decomposition.
+
+ -- Constant: int UC_DECOMP_FONT
+     UCD marker: `<font>'.  Denotes a font variant (e.g. a blackletter
+     form).
+
+ -- Constant: int UC_DECOMP_NOBREAK
+     UCD marker: `<noBreak>'.  Denotes a no-break version of a space or
+     hyphen.
+
+ -- Constant: int UC_DECOMP_INITIAL
+     UCD marker: `<initial>'.  Denotes an initial presentation form
+     (Arabic).
+
+ -- Constant: int UC_DECOMP_MEDIAL
+     UCD marker: `<medial>'.  Denotes a medial presentation form
+     (Arabic).
+
+ -- Constant: int UC_DECOMP_FINAL
+     UCD marker: `<final>'.  Denotes a final presentation form (Arabic).
+
+ -- Constant: int UC_DECOMP_ISOLATED
+     UCD marker: `<isolated>'.  Denotes an isolated presentation form
+     (Arabic).
+
+ -- Constant: int UC_DECOMP_CIRCLE
+     UCD marker: `<circle>'.  Denotes an encircled form.
+
+ -- Constant: int UC_DECOMP_SUPER
+     UCD marker: `<super>'.  Denotes a superscript form.
+
+ -- Constant: int UC_DECOMP_SUB
+     UCD marker: `<sub>'.  Denotes a subscript form.
+
+ -- Constant: int UC_DECOMP_VERTICAL
+     UCD marker: `<vertical>'.  Denotes a vertical layout presentation
+     form.
+
+ -- Constant: int UC_DECOMP_WIDE
+     UCD marker: `<wide>'.  Denotes a wide (or zenkaku) compatibility
+     character.
+
+ -- Constant: int UC_DECOMP_NARROW
+     UCD marker: `<narrow>'.  Denotes a narrow (or hankaku)
+     compatibility character.
+
+ -- Constant: int UC_DECOMP_SMALL
+     UCD marker: `<small>'.  Denotes a small variant form (CNS
+     compatibility).
+
+ -- Constant: int UC_DECOMP_SQUARE
+     UCD marker: `<square>'.  Denotes a CJK squared font variant.
+
+ -- Constant: int UC_DECOMP_FRACTION
+     UCD marker: `<fraction>'.  Denotes a vulgar fraction form.
+
+ -- Constant: int UC_DECOMP_COMPAT
+     UCD marker: `<compat>'.  Denotes an otherwise unspecified
+     compatibility character.
+
+   The following constant denotes the maximum size of decomposition of
+a single Unicode character.
+
+ -- Macro: unsigned int UC_DECOMPOSITION_MAX_LENGTH
+     This macro expands to a constant that is the required size of
+     buffer passed to the `uc_decomposition' and
+     `uc_canonical_decomposition' functions.
+
+   The following functions decompose a Unicode character.
+
+ -- Function: int uc_decomposition (ucs4_t UC, int *DECOMP_TAG, ucs4_t
+          *DECOMPOSITION)
+     Returns the character decomposition mapping of the Unicode
+     character UC.  DECOMPOSITION must point to an array of at least
+     `UC_DECOMPOSITION_MAX_LENGTH' `ucs_t' elements.
+
+     When a decomposition exists, `DECOMPOSITION[0..N-1]' and
+     `*DECOMP_TAG' are filled and N is returned.  Otherwise -1 is
+     returned.
+
+ -- Function: int uc_canonical_decomposition (ucs4_t UC, ucs4_t
+          *DECOMPOSITION)
+     Returns the canonical character decomposition mapping of the
+     Unicode character UC.  DECOMPOSITION must point to an array of at
+     least `UC_DECOMPOSITION_MAX_LENGTH' `ucs_t' elements.
+
+     When a decomposition exists, `DECOMPOSITION[0..N-1]' is filled and
+     N is returned.  Otherwise -1 is returned.
+
+
+File: libunistring.info,  Node: Composition of characters,  Next: Normalization of strings,  Prev: Decomposition of characters,  Up: uninorm.h
+
+12.2 Composition of Unicode characters
+======================================
+
+   The following function composes a Unicode character from two Unicode
+characters.
+
+ -- Function: ucs4_t uc_composition (ucs4_t UC1, ucs4_t UC2)
+     Attempts to combine the Unicode characters UC1, UC2.  UC1 is known
+     to have canonical combining class 0.
+
+     Returns the combination of UC1 and UC2, if it exists.  Returns 0
+     otherwise.
+
+     Not all decompositions can be recombined using this function.  See
+     the Unicode file `CompositionExclusions.txt' for details.
+
+
+File: libunistring.info,  Node: Normalization of strings,  Next: Normalizing comparisons,  Prev: Composition of characters,  Up: uninorm.h
+
+12.3 Normalization of strings
+=============================
+
+   The Unicode standard defines four normalization forms for Unicode
+strings.  The following type is used to denote a normalization form.
+
+ -- Type: uninorm_t
+     An object of type `uninorm_t' denotes a Unicode normalization form.
+     This is a scalar type; its values can be compared with `=='.
+
+   The following constants denote the four normalization forms.
+
+ -- Macro: uninorm_t UNINORM_NFD
+     Denotes Normalization form D: canonical decomposition.
+
+ -- Macro: uninorm_t UNINORM_NFC
+     Normalization form C: canonical decomposition, then canonical
+     composition.
+
+ -- Macro: uninorm_t UNINORM_NFKD
+     Normalization form KD: compatibility decomposition.
+
+ -- Macro: uninorm_t UNINORM_NFKC
+     Normalization form KC: compatibility decomposition, then canonical
+     composition.
+
+   The following functions operate on `uninorm_t' objects.
+
+ -- Function: bool uninorm_is_compat_decomposing (uninorm_t NF)
+     Tests whether the normalization form NF does compatibility
+     decomposition.
+
+ -- Function: bool uninorm_is_composing (uninorm_t NF)
+     Tests whether the normalization form NF includes canonical
+     composition.
+
+ -- Function: uninorm_t uninorm_decomposing_form (uninorm_t NF)
+     Returns the decomposing variant of the normalization form NF.
+     This maps NFC,NFD -> NFD and NFKC,NFKD -> NFKD.
+
+   The following functions apply a Unicode normalization form to a
+Unicode string.
+
+ -- Function: uint8_t * u8_normalize (uninorm_t NF, const uint8_t *S,
+          size_t N, uint8_t *RESULTBUF, size_t *LENGTHP)
+ -- Function: uint16_t * u16_normalize (uninorm_t NF, const uint16_t
+          *S, size_t N, uint16_t *RESULTBUF, size_t *LENGTHP)
+ -- Function: uint32_t * u32_normalize (uninorm_t NF, const uint32_t
+          *S, size_t N, uint32_t *RESULTBUF, size_t *LENGTHP)
+     Returns the specified normalization form of a string.
+
+
+File: libunistring.info,  Node: Normalizing comparisons,  Next: Normalization of streams,  Prev: Normalization of strings,  Up: uninorm.h
+
+12.4 Normalizing comparisons
+============================
+
+   The following functions compare Unicode string, ignoring differences
+in normalization.
+
+ -- Function: int u8_normcmp (const uint8_t *S1, size_t N1, const
+          uint8_t *S2, size_t N2, uninorm_t NF, int *RESULTP)
+ -- Function: int u16_normcmp (const uint16_t *S1, size_t N1, const
+          uint16_t *S2, size_t N2, uninorm_t NF, int *RESULTP)
+ -- Function: int u32_normcmp (const uint32_t *S1, size_t N1, const
+          uint32_t *S2, size_t N2, uninorm_t NF, int *RESULTP)
+     Compares S1 and S2, ignoring differences in normalization.
+
+     NF must be either `UNINORM_NFD' or `UNINORM_NFKD'.
+
+     If successful, sets `*RESULTP' to -1 if S1 < S2, 0 if S1 = S2, 1
+     if S1 > S2, and returns 0.  Upon failure, returns -1 with `errno'
+     set.
+
+ -- Function: char * u8_normxfrm (const uint8_t *S, size_t N, uninorm_t
+          NF, char *RESULTBUF, size_t *LENGTHP)
+ -- Function: char * u16_normxfrm (const uint16_t *S, size_t N,
+          uninorm_t NF, char *RESULTBUF, size_t *LENGTHP)
+ -- Function: char * u32_normxfrm (const uint32_t *S, size_t N,
+          uninorm_t NF, char *RESULTBUF, size_t *LENGTHP)
+     Converts the string S of length N to a NUL-terminated byte
+     sequence, in such a way that comparing `u8_normxfrm (S1)' and
+     `u8_normxfrm (S2)' with the `u8_cmp2' function is equivalent to
+     comparing S1 and S2 with the `u8_normcoll' function.
+
+     NF must be either `UNINORM_NFC' or `UNINORM_NFKC'.
+
+ -- Function: int u8_normcoll (const uint8_t *S1, size_t N1, const
+          uint8_t *S2, size_t N2, uninorm_t NF, int *RESULTP)
+ -- Function: int u16_normcoll (const uint16_t *S1, size_t N1, const
+          uint16_t *S2, size_t N2, uninorm_t NF, int *RESULTP)
+ -- Function: int u32_normcoll (const uint32_t *S1, size_t N1, const
+          uint32_t *S2, size_t N2, uninorm_t NF, int *RESULTP)
+     Compares 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, sets `*RESULTP' to -1 if S1 < S2, 0 if S1 = S2, 1
+     if S1 > S2, and returns 0.  Upon failure, returns -1 with `errno'
+     set.
+
+
+File: libunistring.info,  Node: Normalization of streams,  Prev: Normalizing comparisons,  Up: uninorm.h
+
+12.5 Normalization of streams 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.
+
+ -- Type: struct uninorm_filter
+     This is the 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.
+
+ -- Function: struct uninorm_filter * uninorm_filter_create (uninorm_t
+          NF, int (*STREAM_FUNC) (void *STREAM_DATA, ucs4_t UC), void
+          *STREAM_DATA)
+     Creates and returns 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.
+
+     Returns the new filter, or NULL with `errno' set upon failure.
+
+ -- Function: int uninorm_filter_write (struct uninorm_filter *FILTER,
+          ucs4_t UC)
+     Stuffs a Unicode character into a normalizing filter.  Returns 0
+     if successful, or -1 with `errno' set upon failure.
+
+ -- Function: int uninorm_filter_flush (struct uninorm_filter *FILTER)
+     Brings data buffered in the filter to its destination, the
+     encapsulated stream.
+
+     Returns 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.
+
+ -- Function: int uninorm_filter_free (struct uninorm_filter *FILTER)
+     Brings data buffered in the filter to its destination, the
+     encapsulated stream, then closes and frees the filter.
+
+     Returns 0 if successful, or -1 with `errno' set upon failure.
+
+
+File: libunistring.info,  Node: unicase.h,  Next: uniregex.h,  Prev: uninorm.h,  Up: Top
+
+13 Case mappings `<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 *note
+char * strings::, namely, they handle the Croatian LETTER DZ WITH
+CARON, the German 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::
+
+
+File: libunistring.info,  Node: Case mappings of characters,  Next: Case mappings of strings,  Up: unicase.h
+
+13.1 Case mappings of characters
+================================
+
+   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.
+
+   *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.
+
+ -- Function: ucs4_t uc_toupper (ucs4_t UC)
+     Returns the uppercase mapping of the Unicode character UC.
+
+ -- Function: ucs4_t uc_tolower (ucs4_t UC)
+     Returns the lowercase mapping of the Unicode character UC.
+
+ -- Function: ucs4_t uc_totitle (ucs4_t UC)
+     Returns the titlecase mapping of the Unicode character 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.
+
+     Lower case            Title case            Upper case
+     ------------------------------------------------------------------ 
+     LATIN SMALL LETTER LJ LATIN CAPITAL LETTER  LATIN CAPITAL LETTER
+                           L WITH SMALL LETTER J LJ
+     LATIN SMALL LETTER NJ LATIN CAPITAL LETTER  LATIN CAPITAL LETTER
+                           N WITH SMALL LETTER J NJ
+     LATIN SMALL LETTER DZ LATIN CAPITAL LETTER  LATIN CAPITAL LETTER
+                           D WITH SMALL LETTER Z DZ
+     LATIN SMALL LETTER    LATIN CAPITAL LETTER  LATIN CAPITAL LETTER
+     DZ WITH CARON         D WITH SMALL LETTER   DZ WITH CARON
+                           Z WITH CARON          
+
+
+File: libunistring.info,  Node: Case mappings of strings,  Next: Case mappings of substrings,  Prev: Case mappings of characters,  Up: unicase.h
+
+13.2 Case mappings of strings
+=============================
+
+   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 `ä' and `Ä' the
+same, you most often also want to treat the composed and decomposed
+forms of such a character, U+00C4 LATIN CAPITAL LETTER A WITH DIAERESIS
+and U+0041 LATIN CAPITAL LETTER A U+0308 COMBINING DIAERESIS the same.
+The NF argument designates the normalization.
+
+   These functions are locale dependent.  The ISO639_LANGUAGE argument
+identifies the language (e.g. `"tr"' for Turkish).  NULL means to use
+locale independent case mappings.
+
+ -- Function: const char * uc_locale_language ()
+     Returns the ISO 639 language code of the current locale.  Returns
+     `""' if it is unknown, or in the "C" locale.
+
+ -- Function: uint8_t * u8_toupper (const uint8_t *S, size_t N, const
+          char *ISO639_LANGUAGE, uninorm_t NF, uint8_t *RESULTBUF,
+          size_t *LENGTHP)
+ -- Function: uint16_t * u16_toupper (const uint16_t *S, size_t N,
+          const char *ISO639_LANGUAGE, uninorm_t NF, uint16_t
+          *RESULTBUF, size_t *LENGTHP)
+ -- Function: uint32_t * u32_toupper (const uint32_t *S, size_t N,
+          const char *ISO639_LANGUAGE, uninorm_t NF, uint32_t
+          *RESULTBUF, size_t *LENGTHP)
+     Returns the uppercase mapping of a string.
+
+     The NF argument identifies the normalization form to apply after
+     the case-mapping.  It can also be NULL, for no normalization.
+
+ -- Function: uint8_t * u8_tolower (const uint8_t *S, size_t N, const
+          char *ISO639_LANGUAGE, uninorm_t NF, uint8_t *RESULTBUF,
+          size_t *LENGTHP)
+ -- Function: uint16_t * u16_tolower (const uint16_t *S, size_t N,
+          const char *ISO639_LANGUAGE, uninorm_t NF, uint16_t
+          *RESULTBUF, size_t *LENGTHP)
+ -- Function: uint32_t * u32_tolower (const uint32_t *S, size_t N,
+          const char *ISO639_LANGUAGE, uninorm_t NF, uint32_t
+          *RESULTBUF, size_t *LENGTHP)
+     Returns the lowercase mapping of a string.
+
+     The NF argument identifies the normalization form to apply after
+     the case-mapping.  It can also be NULL, for no normalization.
+
+ -- Function: uint8_t * u8_totitle (const uint8_t *S, size_t N, const
+          char *ISO639_LANGUAGE, uninorm_t NF, uint8_t *RESULTBUF,
+          size_t *LENGTHP)
+ -- Function: uint16_t * u16_totitle (const uint16_t *S, size_t N,
+          const char *ISO639_LANGUAGE, uninorm_t NF, uint16_t
+          *RESULTBUF, size_t *LENGTHP)
+ -- Function: uint32_t * u32_totitle (const uint32_t *S, size_t N,
+          const char *ISO639_LANGUAGE, uninorm_t NF, uint32_t
+          *RESULTBUF, size_t *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 NF argument identifies the normalization form to apply after
+     the case-mapping.  It can also be NULL, for no normalization.
+
+
+File: libunistring.info,  Node: Case mappings of substrings,  Next: Case insensitive comparison,  Prev: Case mappings of strings,  Up: unicase.h
+
+13.3 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").
+
+ -- 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.
+
+ -- Constant: casing_prefix_context_t unicase_empty_prefix_context
+     This constant is the case-mapping context that corresponds to an
+     empty prefix string.
+
+   The following functions return `casing_prefix_context_t' objects:
+
+ -- Function: casing_prefix_context_t u8_casing_prefix_context (const
+          uint8_t *S, size_t N)
+ -- Function: casing_prefix_context_t u16_casing_prefix_context (const
+          uint16_t *S, size_t N)
+ -- Function: casing_prefix_context_t u32_casing_prefix_context (const
+          uint32_t *S, size_t N)
+     Returns the case-mapping context of a given prefix string.
+
+ -- Function: casing_prefix_context_t u8_casing_prefixes_context (const
+          uint8_t *S, size_t N, casing_prefix_context_t A_CONTEXT)
+ -- Function: casing_prefix_context_t u16_casing_prefixes_context
+          (const uint16_t *S, size_t N, casing_prefix_context_t
+          A_CONTEXT)
+ -- Function: casing_prefix_context_t u32_casing_prefixes_context
+          (const uint32_t *S, size_t N, casing_prefix_context_t
+          A_CONTEXT)
+     Returns the case-mapping context of the prefix concat(A, S), given
+     the case-mapping context of the prefix A.
+
+ -- 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.
+
+ -- Constant: casing_suffix_context_t unicase_empty_suffix_context
+     This constant is the case-mapping context that corresponds to an
+     empty suffix string.
+
+   The following functions return `casing_suffix_context_t' objects:
+
+ -- Function: casing_suffix_context_t u8_casing_suffix_context (const
+          uint8_t *S, size_t N)
+ -- Function: casing_suffix_context_t u16_casing_suffix_context (const
+          uint16_t *S, size_t N)
+ -- Function: casing_suffix_context_t u32_casing_suffix_context (const
+          uint32_t *S, size_t N)
+     Returns the case-mapping context of a given suffix string.
+
+ -- Function: casing_suffix_context_t u8_casing_suffixes_context (const
+          uint8_t *S, size_t N, casing_suffix_context_t A_CONTEXT)
+ -- Function: casing_suffix_context_t u16_casing_suffixes_context
+          (const uint16_t *S, size_t N, casing_suffix_context_t
+          A_CONTEXT)
+ -- Function: casing_suffix_context_t u32_casing_suffixes_context
+          (const uint32_t *S, size_t N, casing_suffix_context_t
+          A_CONTEXT)
+     Returns the case-mapping context of the suffix concat(S, A), given
+     the case-mapping context of the suffix A.
+
+   The following functions perform a case mapping, considering the
+prefix context and the suffix context.
+
+ -- Function: uint8_t * u8_ct_toupper (const uint8_t *S, size_t N,
+          casing_prefix_context_t PREFIX_CONTEXT,
+          casing_suffix_context_t SUFFIX_CONTEXT, const char
+          *ISO639_LANGUAGE, uninorm_t NF, uint8_t *RESULTBUF, size_t
+          *LENGTHP)
+ -- Function: uint16_t * u16_ct_toupper (const uint16_t *S, size_t N,
+          casing_prefix_context_t PREFIX_CONTEXT,
+          casing_suffix_context_t SUFFIX_CONTEXT, const char
+          *ISO639_LANGUAGE, uninorm_t NF, uint16_t *RESULTBUF, size_t
+          *LENGTHP)
+ -- Function: uint32_t * u32_ct_toupper (const uint32_t *S, size_t N,
+          casing_prefix_context_t PREFIX_CONTEXT,
+          casing_suffix_context_t SUFFIX_CONTEXT, const char
+          *ISO639_LANGUAGE, uninorm_t NF, uint32_t *RESULTBUF, size_t
+          *LENGTHP)
+     Returns the uppercase mapping of a string that is surrounded by a
+     prefix and a suffix.
+
+ -- Function: uint8_t * u8_ct_tolower (const uint8_t *S, size_t N,
+          casing_prefix_context_t PREFIX_CONTEXT,
+          casing_suffix_context_t SUFFIX_CONTEXT, const char
+          *ISO639_LANGUAGE, uninorm_t NF, uint8_t *RESULTBUF, size_t
+          *LENGTHP)
+ -- Function: uint16_t * u16_ct_tolower (const uint16_t *S, size_t N,
+          casing_prefix_context_t PREFIX_CONTEXT,
+          casing_suffix_context_t SUFFIX_CONTEXT, const char
+          *ISO639_LANGUAGE, uninorm_t NF, uint16_t *RESULTBUF, size_t
+          *LENGTHP)
+ -- Function: uint32_t * u32_ct_tolower (const uint32_t *S, size_t N,
+          casing_prefix_context_t PREFIX_CONTEXT,
+          casing_suffix_context_t SUFFIX_CONTEXT, const char
+          *ISO639_LANGUAGE, uninorm_t NF, uint32_t *RESULTBUF, size_t
+          *LENGTHP)
+     Returns the lowercase mapping of a string that is surrounded by a
+     prefix and a suffix.
+
+ -- Function: uint8_t * u8_ct_totitle (const uint8_t *S, size_t N,
+          casing_prefix_context_t PREFIX_CONTEXT,
+          casing_suffix_context_t SUFFIX_CONTEXT, const char
+          *ISO639_LANGUAGE, uninorm_t NF, uint8_t *RESULTBUF, size_t
+          *LENGTHP)
+ -- Function: uint16_t * u16_ct_totitle (const uint16_t *S, size_t N,
+          casing_prefix_context_t PREFIX_CONTEXT,
+          casing_suffix_context_t SUFFIX_CONTEXT, const char
+          *ISO639_LANGUAGE, uninorm_t NF, uint16_t *RESULTBUF, size_t
+          *LENGTHP)
+ -- Function: uint32_t * u32_ct_totitle (const uint32_t *S, size_t N,
+          casing_prefix_context_t PREFIX_CONTEXT,
+          casing_suffix_context_t SUFFIX_CONTEXT, const char
+          *ISO639_LANGUAGE, uninorm_t NF, uint32_t *RESULTBUF, size_t
+          *LENGTHP)
+     Returns the titlecase mapping of a string that is surrounded by a
+     prefix and a suffix.
+
+   For example, to uppercase the UTF-8 substring between `s +
+start_index' and `s + end_index' of a string that extends from `s' to
+`s + u8_strlen (s)', you can use the statements
+
+     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);
+
+
+File: libunistring.info,  Node: Case insensitive comparison,  Next: Case detection,  Prev: Case mappings of substrings,  Up: unicase.h
+
+13.4 Case insensitive comparison
+================================
+
+   The following functions implement comparison that ignores
+differences in case and normalization.
+
+ -- Function: uint8_t * u8_casefold (const uint8_t *S, size_t N, const
+          char *ISO639_LANGUAGE, uninorm_t NF, uint8_t *RESULTBUF,
+          size_t *LENGTHP)
+ -- Function: uint16_t * u16_casefold (const uint16_t *S, size_t N,
+          const char *ISO639_LANGUAGE, uninorm_t NF, uint16_t
+          *RESULTBUF, size_t *LENGTHP)
+ -- Function: uint32_t * u32_casefold (const uint32_t *S, size_t N,
+          const char *ISO639_LANGUAGE, uninorm_t NF, uint32_t
+          *RESULTBUF, size_t *LENGTHP)
+     Returns the case folded string.
+
+     Comparing `u8_casefold (S1)' and `u8_casefold (S2)' with the
+     `u8_cmp2' function is equivalent to comparing S1 and S2 with
+     `u8_casecmp'.
+
+     The NF argument identifies the normalization form to apply after
+     the case-mapping.  It can also be NULL, for no normalization.
+
+ -- Function: uint8_t * u8_ct_casefold (const uint8_t *S, size_t N,
+          casing_prefix_context_t PREFIX_CONTEXT,
+          casing_suffix_context_t SUFFIX_CONTEXT, const char
+          *ISO639_LANGUAGE, uninorm_t NF, uint8_t *RESULTBUF, size_t
+          *LENGTHP)
+ -- Function: uint16_t * u16_ct_casefold (const uint16_t *S, size_t N,
+          casing_prefix_context_t PREFIX_CONTEXT,
+          casing_suffix_context_t SUFFIX_CONTEXT, const char
+          *ISO639_LANGUAGE, uninorm_t NF, uint16_t *RESULTBUF, size_t
+          *LENGTHP)
+ -- Function: uint32_t * u32_ct_casefold (const uint32_t *S, size_t N,
+          casing_prefix_context_t PREFIX_CONTEXT,
+          casing_suffix_context_t SUFFIX_CONTEXT, const char
+          *ISO639_LANGUAGE, uninorm_t NF, uint32_t *RESULTBUF, size_t
+          *LENGTHP)
+     Returns the case folded string.  The case folding takes into
+     account the case mapping contexts of the prefix and suffix strings.
+
+ -- Function: int u8_casecmp (const uint8_t *S1, size_t N1, const
+          uint8_t *S2, size_t N2, const char *ISO639_LANGUAGE,
+          uninorm_t NF, int *RESULTP)
+ -- Function: int u16_casecmp (const uint16_t *S1, size_t N1, const
+          uint16_t *S2, size_t N2, const char *ISO639_LANGUAGE,
+          uninorm_t NF, int *RESULTP)
+ -- Function: int u32_casecmp (const uint32_t *S1, size_t N1, const
+          uint32_t *S2, size_t N2, const char *ISO639_LANGUAGE,
+          uninorm_t NF, int *RESULTP)
+ -- Function: int ulc_casecmp (const char *S1, size_t N1, const char
+          *S2, size_t N2, const char *ISO639_LANGUAGE, uninorm_t NF,
+          int *RESULTP)
+     Compares S1 and S2, ignoring differences in case and normalization.
+
+     The NF argument identifies the normalization form to apply after
+     the case-mapping.  It can also be NULL, for no normalization.
+
+     If successful, sets `*RESULTP' to -1 if S1 < S2, 0 if S1 = S2, 1
+     if S1 > S2, and returns 0.  Upon failure, returns -1 with `errno'
+     set.
+
+   The following functions additionally take into account the sorting
+rules of the current locale.
+
+ -- Function: char * u8_casexfrm (const uint8_t *S, size_t N, const
+          char *ISO639_LANGUAGE, uninorm_t NF, char *RESULTBUF, size_t
+          *LENGTHP)
+ -- Function: char * u16_casexfrm (const uint16_t *S, size_t N, const
+          char *ISO639_LANGUAGE, uninorm_t NF, char *RESULTBUF, size_t
+          *LENGTHP)
+ -- Function: char * u32_casexfrm (const uint32_t *S, size_t N, const
+          char *ISO639_LANGUAGE, uninorm_t NF, char *RESULTBUF, size_t
+          *LENGTHP)
+ -- Function: char * ulc_casexfrm (const char *S, size_t N, const char
+          *ISO639_LANGUAGE, uninorm_t NF, char *RESULTBUF, size_t
+          *LENGTHP)
+     Converts the string S of length N to a NUL-terminated byte
+     sequence, in such a way that comparing `u8_casexfrm (S1)' and
+     `u8_casexfrm (S2)' with the gnulib function `memcmp2' is
+     equivalent to comparing S1 and S2 with `u8_casecoll'.
+
+     NF must be either `UNINORM_NFC', `UNINORM_NFKC', or NULL for no
+     normalization.
+
+ -- Function: int u8_casecoll (const uint8_t *S1, size_t N1, const
+          uint8_t *S2, size_t N2, const char *ISO639_LANGUAGE,
+          uninorm_t NF, int *RESULTP)
+ -- Function: int u16_casecoll (const uint16_t *S1, size_t N1, const
+          uint16_t *S2, size_t N2, const char *ISO639_LANGUAGE,
+          uninorm_t NF, int *RESULTP)
+ -- Function: int u32_casecoll (const uint32_t *S1, size_t N1, const
+          uint32_t *S2, size_t N2, const char *ISO639_LANGUAGE,
+          uninorm_t NF, int *RESULTP)
+ -- Function: int ulc_casecoll (const char *S1, size_t N1, const char
+          *S2, size_t N2, const char *ISO639_LANGUAGE, uninorm_t NF,
+          int *RESULTP)
+     Compares S1 and S2, ignoring differences in case and normalization,
+     using the collation rules of the current locale.
+
+     The NF argument identifies the normalization form to apply after
+     the case-mapping.  It must be either `UNINORM_NFC' or
+     `UNINORM_NFKC'.  It can also be NULL, for no normalization.
+
+     If successful, sets `*RESULTP' to -1 if S1 < S2, 0 if S1 = S2, 1
+     if S1 > S2, and returns 0.  Upon failure, returns -1 with `errno'
+     set.
+
+
+File: libunistring.info,  Node: Case detection,  Prev: Case insensitive comparison,  Up: unicase.h
+
+13.5 Case detection
+===================
+
+   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.
+
+ -- Function: int u8_is_uppercase (const uint8_t *S, size_t N, const
+          char *ISO639_LANGUAGE, bool *RESULTP)
+ -- Function: int u16_is_uppercase (const uint16_t *S, size_t N, const
+          char *ISO639_LANGUAGE, bool *RESULTP)
+ -- Function: int u32_is_uppercase (const uint32_t *S, size_t N, const
+          char *ISO639_LANGUAGE, bool *RESULTP)
+     Sets `*RESULTP' to true if mapping NFD(S) to upper case is a
+     no-op, or to false otherwise, and returns 0.  Upon failure,
+     returns -1 with `errno' set.
+
+ -- Function: int u8_is_lowercase (const uint8_t *S, size_t N, const
+          char *ISO639_LANGUAGE, bool *RESULTP)
+ -- Function: int u16_is_lowercase (const uint16_t *S, size_t N, const
+          char *ISO639_LANGUAGE, bool *RESULTP)
+ -- Function: int u32_is_lowercase (const uint32_t *S, size_t N, const
+          char *ISO639_LANGUAGE, bool *RESULTP)
+     Sets `*RESULTP' to true if mapping NFD(S) to lower case is a
+     no-op, or to false otherwise, and returns 0.  Upon failure,
+     returns -1 with `errno' set.
+
+ -- Function: int u8_is_titlecase (const uint8_t *S, size_t N, const
+          char *ISO639_LANGUAGE, bool *RESULTP)
+ -- Function: int u16_is_titlecase (const uint16_t *S, size_t N, const
+          char *ISO639_LANGUAGE, bool *RESULTP)
+ -- Function: int u32_is_titlecase (const uint32_t *S, size_t N, const
+          char *ISO639_LANGUAGE, bool *RESULTP)
+     Sets `*RESULTP' to true if mapping NFD(S) to title case is a
+     no-op, or to false otherwise, and returns 0.  Upon failure,
+     returns -1 with `errno' set.
+
+ -- Function: int u8_is_casefolded (const uint8_t *S, size_t N, const
+          char *ISO639_LANGUAGE, bool *RESULTP)
+ -- Function: int u16_is_casefolded (const uint16_t *S, size_t N, const
+          char *ISO639_LANGUAGE, bool *RESULTP)
+ -- Function: int u32_is_casefolded (const uint32_t *S, size_t N, const
+          char *ISO639_LANGUAGE, bool *RESULTP)
+     Sets `*RESULTP' to true if applying case folding to NFD(S) is a
+     no-op, or to false otherwise, and returns 0.  Upon failure,
+     returns -1 with `errno' set.
+
+   The following functions determine whether case mappings have any
+effect on a Unicode string.
+
+ -- Function: int u8_is_cased (const uint8_t *S, size_t N, const char
+          *ISO639_LANGUAGE, bool *RESULTP)
+ -- Function: int u16_is_cased (const uint16_t *S, size_t N, const char
+          *ISO639_LANGUAGE, bool *RESULTP)
+ -- Function: int u32_is_cased (const uint32_t *S, size_t N, const char
+          *ISO639_LANGUAGE, bool *RESULTP)
+     Sets `*RESULTP' to true if case matters for S, that is, if mapping
+     NFD(S) to either upper case or lower case or title case is not a
+     no-op.  Set `*RESULTP' to false if NFD(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(S) consists entirely
+     of caseless characters. Upon failure, returns -1 with `errno' set.
+
+
+File: libunistring.info,  Node: uniregex.h,  Next: Using the library,  Prev: unicase.h,  Up: Top
+
+14 Regular expressions `<uniregex.h>'
+*************************************
+
+   This include file is not yet implemented.
+
+
+File: libunistring.info,  Node: Using the library,  Next: More functionality,  Prev: uniregex.h,  Up: Top
+
+15 Using the library
+********************
+
+   This chapter explains some practical considerations, regarding the
+installation and compiler options that are needed in order to use this
+library.
+
+* Menu:
+
+* Installation::
+* Compiler options::
+* Include files::
+* Autoconf macro::
+* Reporting problems::
+
+
+File: libunistring.info,  Node: Installation,  Next: Compiler options,  Up: Using the library
+
+15.1 Installation
+=================
+
+   Before you can use the library, it must be installed.  First, you
+have to make sure all dependencies are installed.  They are listed in
+the file `DEPENDENCIES'.
+
+   Then you can proceed to build and install the library, as described
+in the file `INSTALL'.  For installation on Windows systems, please
+refer to the file `README.woe32'.
+
+
+File: libunistring.info,  Node: Compiler options,  Next: Include files,  Prev: Installation,  Up: Using the library
+
+15.2 Compiler options
+=====================
+
+   Let's denote as `LIBUNISTRING_PREFIX' the value of the `--prefix'
+option that you passed to `configure' while installing this package.
+If you didn't pass any `--prefix' option, then the package is installed
+in `/usr/local'.
+
+   Let's denote as `LIBUNISTRING_INCLUDEDIR' the directory where the
+include files were installed.  This is usually the same as
+`${LIBUNISTRING_PREFIX}/include'.  Except that if you passed an
+`--includedir' option to `configure', it is the value of that option.
+
+   Let's further denote as `LIBUNISTRING_LIBDIR' the directory where
+the library itself was installed.  This is the value that you passed
+with the `--libdir' option to `configure', or otherwise the same as
+`${LIBUNISTRING_PREFIX}/lib'.  Recall that when building in 64-bit mode
+on a 64-bit GNU/Linux system that supports executables in either 64-bit
+mode or 32-bit mode, you should have used the option
+`--libdir=${LIBUNISTRING_PREFIX}/lib64'.
+
+   So that the compiler finds the include files, you have to pass it the
+option `-I${LIBUNISTRING_INCLUDEDIR}'.
+
+   So that the compiler finds the library during its linking pass, you
+have to pass it the options `-L${LIBUNISTRING_LIBDIR} -lunistring'.  On
+some systems, in some configurations, you also have to pass options
+needed for linking with `libiconv'.  The autoconf macro
+`gl_LIBUNISTRING' (see *note Autoconf macro::) deals with this
+particularity.
+
+
+File: libunistring.info,  Node: Include files,  Next: Autoconf macro,  Prev: Compiler options,  Up: Using the library
+
+15.3 Include files
+==================
+
+   Most of the include files have been presented in the introduction,
+see *note Introduction::, and subsequent detailed chapters.
+
+   Another include file is `<unistring/version.h>'. It contains the
+version number of the libunistring library.
+
+ -- Macro: int _LIBUNISTRING_VERSION
+     This constant contains the version of libunistring that is being
+     used at compile time.  It encodes the major and minor parts of the
+     version number only.  These parts are encoded in the form
+     `(major<<8) + minor'.
+
+ -- Constant: int _libunistring_version
+     This constant contains the version of libunistring that is being
+     used at run time.  It encodes the major and minor parts of the
+     version number only.  These parts are encoded in the form
+     `(major<<8) + minor'.
+
+   It is possible that `_libunistring_version' is greater than
+`_LIBUNISTRING_VERSION'.  This can happen when you use `libunistring'
+as a shared library, and a newer, binary backward-compatible version
+has been installed after your program that uses `libunistring' was
+installed.
+
+
+File: libunistring.info,  Node: Autoconf macro,  Next: Reporting problems,  Prev: Include files,  Up: Using the library
+
+15.4 Autoconf macro
+===================
+
+   GNU Gnulib provides an autoconf macro that tests for the availability
+of `libunistring'.  It is contained in the Gnulib module
+`libunistring', see
+`http://www.gnu.org/software/gnulib/MODULES.html#module=libunistring'.
+
+   The macro is called `gl_LIBUNISTRING'.  It searches for an installed
+libunistring.  If found, it sets and AC_SUBSTs `HAVE_LIBUNISTRING=yes'
+and the `LIBUNISTRING' and `LTLIBUNISTRING' variables and augments the
+`CPPFLAGS' variable, and defines the C macro `HAVE_LIBUNISTRING' to 1.
+Otherwise, it sets and AC_SUBSTs `HAVE_LIBUNISTRING=no' and
+`LIBUNISTRING' and `LTLIBUNISTRING' to empty.
+
+   The complexities that `gl_LIBUNISTRING' deals with are the following:
+
+   * On some operating systems, in some configurations, libunistring
+     depends on `libiconv', and the options for linking with libiconv
+     must be mentioned explicitly on the link command line.
+
+   * GNU `libunistring', if installed, is not necessarily already in the
+     search path (`CPPFLAGS' for the include file search path,
+     `LDFLAGS' for the library search path).
+
+   * GNU `libunistring', if installed, is not necessarily already in the
+     run time library search path.  To avoid the need for setting an
+     environment variable like `LD_LIBRARY_PATH', the macro adds the
+     appropriate run time search path options to the `LIBUNISTRING'
+     variable.  This works on most systems.
+
+
+File: libunistring.info,  Node: Reporting problems,  Prev: Autoconf macro,  Up: Using the library
+
+15.5 Reporting problems
+=======================
+
+   If you encounter any problem, please don't hesitate to send a
+detailed bug report to the `bug-libunistring@gnu.org' mailing list.
+You can alternatively also use the bug tracker at the project page
+`https://savannah.gnu.org/projects/libunistring'.
+
+   Please always include the version number of this library, and a short
+description of your operating system and compilation environment with
+corresponding version numbers.
+
+   For problems that appear while building and installing
+`libunistring', for which you don't find the remedy in the `INSTALL'
+file, please include a description of the options that you passed to
+the `configure' script.
+
+
+File: libunistring.info,  Node: More functionality,  Next: Licenses,  Prev: Using the library,  Up: Top
+
+16 More advanced functionality
+******************************
+
+   For bidirectional reordering of strings, we recommend the GNU
+FriBidi library: `http://www.fribidi.org/'.
+
+   For the rendering of Unicode strings outside of the context of a
+given toolkit (KDE/Qt or GNOME/Gtk), we recommend the Pango library:
+`http://www.pango.org/'.
+
+
+File: libunistring.info,  Node: Licenses,  Next: Index,  Prev: More functionality,  Up: Top
+
+Appendix A Licenses
+*******************
+
+   The files of this package are covered by the licenses indicated in
+each particular file or directory.  Here is a summary:
+
+   * The `libunistring' library is covered by the GNU Lesser General
+     Public License (LGPL).  A copy of the license is included in *note
+     GNU LGPL::.
+
+   * This manual is free documentation.  It is dually licensed under the
+     GNU FDL and the GNU GPL.  This means that you can redistribute this
+     manual under either of these two licenses, at your choice.
+     This manual is covered by the GNU FDL.  Permission is granted to
+     copy, distribute and/or modify this document under the terms of the
+     GNU Free Documentation License (FDL), either version 1.2 of the
+     License, or (at your option) any later version published by the
+     Free Software Foundation (FSF); with no Invariant Sections, with no
+     Front-Cover Text, and with no Back-Cover Texts.  A copy of the
+     license is included in *note GNU FDL::.
+     This manual is covered by the GNU GPL.  You can redistribute it
+     and/or modify it under the terms of the GNU General Public License
+     (GPL), either version 3 of the License, or (at your option) any
+     later version published by the Free Software Foundation (FSF).  A
+     copy of the license is included in *note GNU GPL::.
+
+* Menu:
+
+* GNU GPL::                     GNU General Public License
+* GNU LGPL::                    GNU Lesser General Public License
+* GNU FDL::                     GNU Free Documentation License
+
+
+File: libunistring.info,  Node: GNU GPL,  Next: GNU LGPL,  Up: Licenses
+
+A.1 GNU GENERAL PUBLIC LICENSE
+==============================
+
+                        Version 3, 29 June 2007
+
+     Copyright (C) 2007 Free Software Foundation, Inc. `http://fsf.org/'
+
+     Everyone is permitted to copy and distribute verbatim copies of this
+     license document, but changing it is not allowed.
+
+Preamble
+========
+
+   The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+   The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains
+free software for all its users.  We, the Free Software Foundation, use
+the GNU General Public License for most of our software; it applies
+also to any other work released this way by its authors.  You can apply
+it to your programs, too.
+
+   When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+   To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you
+have certain responsibilities if you distribute copies of the software,
+or if you modify it: responsibilities to respect the freedom of others.
+
+   For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+   Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+   For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+   Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the
+manufacturer can do so.  This is fundamentally incompatible with the
+aim of protecting users' freedom to change the software.  The
+systematic pattern of such abuse occurs in the area of products for
+individuals to use, which is precisely where it is most unacceptable.
+Therefore, we have designed this version of the GPL to prohibit the
+practice for those products.  If such problems arise substantially in
+other domains, we stand ready to extend this provision to those domains
+in future versions of the GPL, as needed to protect the freedom of
+users.
+
+   Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+   The precise terms and conditions for copying, distribution and
+modification follow.
+
+TERMS AND CONDITIONS
+====================
+
+  0. Definitions.
+
+     "This License" refers to version 3 of the GNU General Public
+     License.
+
+     "Copyright" also means copyright-like laws that apply to other
+     kinds of works, such as semiconductor masks.
+
+     "The Program" refers to any copyrightable work licensed under this
+     License.  Each licensee is addressed as "you".  "Licensees" and
+     "recipients" may be individuals or organizations.
+
+     To "modify" a work means to copy from or adapt all or part of the
+     work in a fashion requiring copyright permission, other than the
+     making of an exact copy.  The resulting work is called a "modified
+     version" of the earlier work or a work "based on" the earlier work.
+
+     A "covered work" means either the unmodified Program or a work
+     based on the Program.
+
+     To "propagate" a work means to do anything with it that, without
+     permission, would make you directly or secondarily liable for
+     infringement under applicable copyright law, except executing it
+     on a computer or modifying a private copy.  Propagation includes
+     copying, distribution (with or without modification), making
+     available to the public, and in some countries other activities as
+     well.
+
+     To "convey" a work means any kind of propagation that enables other
+     parties to make or receive copies.  Mere interaction with a user
+     through a computer network, with no transfer of a copy, is not
+     conveying.
+
+     An interactive user interface displays "Appropriate Legal Notices"
+     to the extent that it includes a convenient and prominently visible
+     feature that (1) displays an appropriate copyright notice, and (2)
+     tells the user that there is no warranty for the work (except to
+     the extent that warranties are provided), that licensees may
+     convey the work under this License, and how to view a copy of this
+     License.  If the interface presents a list of user commands or
+     options, such as a menu, a prominent item in the list meets this
+     criterion.
+
+  1. Source Code.
+
+     The "source code" for a work means the preferred form of the work
+     for making modifications to it.  "Object code" means any
+     non-source form of a work.
+
+     A "Standard Interface" means an interface that either is an
+     official standard defined by a recognized standards body, or, in
+     the case of interfaces specified for a particular programming
+     language, one that is widely used among developers working in that
+     language.
+
+     The "System Libraries" of an executable work include anything,
+     other than the work as a whole, that (a) is included in the normal
+     form of packaging a Major Component, but which is not part of that
+     Major Component, and (b) serves only to enable use of the work
+     with that Major Component, or to implement a Standard Interface
+     for which an implementation is available to the public in source
+     code form.  A "Major Component", in this context, means a major
+     essential component (kernel, window system, and so on) of the
+     specific operating system (if any) on which the executable work
+     runs, or a compiler used to produce the work, or an object code
+     interpreter used to run it.
+
+     The "Corresponding Source" for a work in object code form means all
+     the source code needed to generate, install, and (for an executable
+     work) run the object code and to modify the work, including
+     scripts to control those activities.  However, it does not include
+     the work's System Libraries, or general-purpose tools or generally
+     available free programs which are used unmodified in performing
+     those activities but which are not part of the work.  For example,
+     Corresponding Source includes interface definition files
+     associated with source files for the work, and the source code for
+     shared libraries and dynamically linked subprograms that the work
+     is specifically designed to require, such as by intimate data
+     communication or control flow between those subprograms and other
+     parts of the work.
+
+     The Corresponding Source need not include anything that users can
+     regenerate automatically from other parts of the Corresponding
+     Source.
+
+     The Corresponding Source for a work in source code form is that
+     same work.
+
+  2. Basic Permissions.
+
+     All rights granted under this License are granted for the term of
+     copyright on the Program, and are irrevocable provided the stated
+     conditions are met.  This License explicitly affirms your unlimited
+     permission to run the unmodified Program.  The output from running
+     a covered work is covered by this License only if the output,
+     given its content, constitutes a covered work.  This License
+     acknowledges your rights of fair use or other equivalent, as
+     provided by copyright law.
+
+     You may make, run and propagate covered works that you do not
+     convey, without conditions so long as your license otherwise
+     remains in force.  You may convey covered works to others for the
+     sole purpose of having them make modifications exclusively for
+     you, or provide you with facilities for running those works,
+     provided that you comply with the terms of this License in
+     conveying all material for which you do not control copyright.
+     Those thus making or running the covered works for you must do so
+     exclusively on your behalf, under your direction and control, on
+     terms that prohibit them from making any copies of your
+     copyrighted material outside their relationship with you.
+
+     Conveying under any other circumstances is permitted solely under
+     the conditions stated below.  Sublicensing is not allowed; section
+     10 makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+     No covered work shall be deemed part of an effective technological
+     measure under any applicable law fulfilling obligations under
+     article 11 of the WIPO copyright treaty adopted on 20 December
+     1996, or similar laws prohibiting or restricting circumvention of
+     such measures.
+
+     When you convey a covered work, you waive any legal power to forbid
+     circumvention of technological measures to the extent such
+     circumvention is effected by exercising rights under this License
+     with respect to the covered work, and you disclaim any intention
+     to limit operation or modification of the work as a means of
+     enforcing, against the work's users, your or third parties' legal
+     rights to forbid circumvention of technological measures.
+
+  4. Conveying Verbatim Copies.
+
+     You may convey verbatim copies of the Program's source code as you
+     receive it, in any medium, provided that you conspicuously and
+     appropriately publish on each copy an appropriate copyright notice;
+     keep intact all notices stating that this License and any
+     non-permissive terms added in accord with section 7 apply to the
+     code; keep intact all notices of the absence of any warranty; and
+     give all recipients a copy of this License along with the Program.
+
+     You may charge any price or no price for each copy that you convey,
+     and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+     You may convey a work based on the Program, or the modifications to
+     produce it from the Program, in the form of source code under the
+     terms of section 4, provided that you also meet all of these
+     conditions:
+
+       a. The work must carry prominent notices stating that you
+          modified it, and giving a relevant date.
+
+       b. The work must carry prominent notices stating that it is
+          released under this License and any conditions added under
+          section 7.  This requirement modifies the requirement in
+          section 4 to "keep intact all notices".
+
+       c. You must license the entire work, as a whole, under this
+          License to anyone who comes into possession of a copy.  This
+          License will therefore apply, along with any applicable
+          section 7 additional terms, to the whole of the work, and all
+          its parts, regardless of how they are packaged.  This License
+          gives no permission to license the work in any other way, but
+          it does not invalidate such permission if you have separately
+          received it.
+
+       d. If the work has interactive user interfaces, each must display
+          Appropriate Legal Notices; however, if the Program has
+          interactive interfaces that do not display Appropriate Legal
+          Notices, your work need not make them do so.
+
+     A compilation of a covered work with other separate and independent
+     works, which are not by their nature extensions of the covered
+     work, and which are not combined with it such as to form a larger
+     program, in or on a volume of a storage or distribution medium, is
+     called an "aggregate" if the compilation and its resulting
+     copyright are not used to limit the access or legal rights of the
+     compilation's users beyond what the individual works permit.
+     Inclusion of a covered work in an aggregate does not cause this
+     License to apply to the other parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+     You may convey a covered work in object code form under the terms
+     of sections 4 and 5, provided that you also convey the
+     machine-readable Corresponding Source under the terms of this
+     License, in one of these ways:
+
+       a. Convey the object code in, or embodied in, a physical product
+          (including a physical distribution medium), accompanied by the
+          Corresponding Source fixed on a durable physical medium
+          customarily used for software interchange.
+
+       b. Convey the object code in, or embodied in, a physical product
+          (including a physical distribution medium), accompanied by a
+          written offer, valid for at least three years and valid for
+          as long as you offer spare parts or customer support for that
+          product model, to give anyone who possesses the object code
+          either (1) a copy of the Corresponding Source for all the
+          software in the product that is covered by this License, on a
+          durable physical medium customarily used for software
+          interchange, for a price no more than your reasonable cost of
+          physically performing this conveying of source, or (2) access
+          to copy the Corresponding Source from a network server at no
+          charge.
+
+       c. Convey individual copies of the object code with a copy of
+          the written offer to provide the Corresponding Source.  This
+          alternative is allowed only occasionally and noncommercially,
+          and only if you received the object code with such an offer,
+          in accord with subsection 6b.
+
+       d. Convey the object code by offering access from a designated
+          place (gratis or for a charge), and offer equivalent access
+          to the Corresponding Source in the same way through the same
+          place at no further charge.  You need not require recipients
+          to copy the Corresponding Source along with the object code.
+          If the place to copy the object code is a network server, the
+          Corresponding Source may be on a different server (operated
+          by you or a third party) that supports equivalent copying
+          facilities, provided you maintain clear directions next to
+          the object code saying where to find the Corresponding Source.
+          Regardless of what server hosts the Corresponding Source, you
+          remain obligated to ensure that it is available for as long
+          as needed to satisfy these requirements.
+
+       e. Convey the object code using peer-to-peer transmission,
+          provided you inform other peers where the object code and
+          Corresponding Source of the work are being offered to the
+          general public at no charge under subsection 6d.
+
+
+     A separable portion of the object code, whose source code is
+     excluded from the Corresponding Source as a System Library, need
+     not be included in conveying the object code work.
+
+     A "User Product" is either (1) a "consumer product", which means
+     any tangible personal property which is normally used for personal,
+     family, or household purposes, or (2) anything designed or sold for
+     incorporation into a dwelling.  In determining whether a product
+     is a consumer product, doubtful cases shall be resolved in favor of
+     coverage.  For a particular product received by a particular user,
+     "normally used" refers to a typical or common use of that class of
+     product, regardless of the status of the particular user or of the
+     way in which the particular user actually uses, or expects or is
+     expected to use, the product.  A product is a consumer product
+     regardless of whether the product has substantial commercial,
+     industrial or non-consumer uses, unless such uses represent the
+     only significant mode of use of the product.
+
+     "Installation Information" for a User Product means any methods,
+     procedures, authorization keys, or other information required to
+     install and execute modified versions of a covered work in that
+     User Product from a modified version of its Corresponding Source.
+     The information must suffice to ensure that the continued
+     functioning of the modified object code is in no case prevented or
+     interfered with solely because modification has been made.
+
+     If you convey an object code work under this section in, or with,
+     or specifically for use in, a User Product, and the conveying
+     occurs as part of a transaction in which the right of possession
+     and use of the User Product is transferred to the recipient in
+     perpetuity or for a fixed term (regardless of how the transaction
+     is characterized), the Corresponding Source conveyed under this
+     section must be accompanied by the Installation Information.  But
+     this requirement does not apply if neither you nor any third party
+     retains the ability to install modified object code on the User
+     Product (for example, the work has been installed in ROM).
+
+     The requirement to provide Installation Information does not
+     include a requirement to continue to provide support service,
+     warranty, or updates for a work that has been modified or
+     installed by the recipient, or for the User Product in which it
+     has been modified or installed.  Access to a network may be denied
+     when the modification itself materially and adversely affects the
+     operation of the network or violates the rules and protocols for
+     communication across the network.
+
+     Corresponding Source conveyed, and Installation Information
+     provided, in accord with this section must be in a format that is
+     publicly documented (and with an implementation available to the
+     public in source code form), and must require no special password
+     or key for unpacking, reading or copying.
+
+  7. Additional Terms.
+
+     "Additional permissions" are terms that supplement the terms of
+     this License by making exceptions from one or more of its
+     conditions.  Additional permissions that are applicable to the
+     entire Program shall be treated as though they were included in
+     this License, to the extent that they are valid under applicable
+     law.  If additional permissions apply only to part of the Program,
+     that part may be used separately under those permissions, but the
+     entire Program remains governed by this License without regard to
+     the additional permissions.
+
+     When you convey a copy of a covered work, you may at your option
+     remove any additional permissions from that copy, or from any part
+     of it.  (Additional permissions may be written to require their own
+     removal in certain cases when you modify the work.)  You may place
+     additional permissions on material, added by you to a covered work,
+     for which you have or can give appropriate copyright permission.
+
+     Notwithstanding any other provision of this License, for material
+     you add to a covered work, you may (if authorized by the copyright
+     holders of that material) supplement the terms of this License
+     with terms:
+
+       a. Disclaiming warranty or limiting liability differently from
+          the terms of sections 15 and 16 of this License; or
+
+       b. Requiring preservation of specified reasonable legal notices
+          or author attributions in that material or in the Appropriate
+          Legal Notices displayed by works containing it; or
+
+       c. Prohibiting misrepresentation of the origin of that material,
+          or requiring that modified versions of such material be
+          marked in reasonable ways as different from the original
+          version; or
+
+       d. Limiting the use for publicity purposes of names of licensors
+          or authors of the material; or
+
+       e. Declining to grant rights under trademark law for use of some
+          trade names, trademarks, or service marks; or
+
+       f. Requiring indemnification of licensors and authors of that
+          material by anyone who conveys the material (or modified
+          versions of it) with contractual assumptions of liability to
+          the recipient, for any liability that these contractual
+          assumptions directly impose on those licensors and authors.
+
+     All other non-permissive additional terms are considered "further
+     restrictions" within the meaning of section 10.  If the Program as
+     you received it, or any part of it, contains a notice stating that
+     it is governed by this License along with a term that is a further
+     restriction, you may remove that term.  If a license document
+     contains a further restriction but permits relicensing or
+     conveying under this License, you may add to a covered work
+     material governed by the terms of that license document, provided
+     that the further restriction does not survive such relicensing or
+     conveying.
+
+     If you add terms to a covered work in accord with this section, you
+     must place, in the relevant source files, a statement of the
+     additional terms that apply to those files, or a notice indicating
+     where to find the applicable terms.
+
+     Additional terms, permissive or non-permissive, may be stated in
+     the form of a separately written license, or stated as exceptions;
+     the above requirements apply either way.
+
+  8. Termination.
+
+     You may not propagate or modify a covered work except as expressly
+     provided under this License.  Any attempt otherwise to propagate or
+     modify it is void, and will automatically terminate your rights
+     under this License (including any patent licenses granted under
+     the third paragraph of section 11).
+
+     However, if you cease all violation of this License, then your
+     license from a particular copyright holder is reinstated (a)
+     provisionally, unless and until the copyright holder explicitly
+     and finally terminates your license, and (b) permanently, if the
+     copyright holder fails to notify you of the violation by some
+     reasonable means prior to 60 days after the cessation.
+
+     Moreover, your license from a particular copyright holder is
+     reinstated permanently if the copyright holder notifies you of the
+     violation by some reasonable means, this is the first time you have
+     received notice of violation of this License (for any work) from
+     that copyright holder, and you cure the violation prior to 30 days
+     after your receipt of the notice.
+
+     Termination of your rights under this section does not terminate
+     the licenses of parties who have received copies or rights from
+     you under this License.  If your rights have been terminated and
+     not permanently reinstated, you do not qualify to receive new
+     licenses for the same material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+     You are not required to accept this License in order to receive or
+     run a copy of the Program.  Ancillary propagation of a covered work
+     occurring solely as a consequence of using peer-to-peer
+     transmission to receive a copy likewise does not require
+     acceptance.  However, nothing other than this License grants you
+     permission to propagate or modify any covered work.  These actions
+     infringe copyright if you do not accept this License.  Therefore,
+     by modifying or propagating a covered work, you indicate your
+     acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+     Each time you convey a covered work, the recipient automatically
+     receives a license from the original licensors, to run, modify and
+     propagate that work, subject to this License.  You are not
+     responsible for enforcing compliance by third parties with this
+     License.
+
+     An "entity transaction" is a transaction transferring control of an
+     organization, or substantially all assets of one, or subdividing an
+     organization, or merging organizations.  If propagation of a
+     covered work results from an entity transaction, each party to that
+     transaction who receives a copy of the work also receives whatever
+     licenses to the work the party's predecessor in interest had or
+     could give under the previous paragraph, plus a right to
+     possession of the Corresponding Source of the work from the
+     predecessor in interest, if the predecessor has it or can get it
+     with reasonable efforts.
+
+     You may not impose any further restrictions on the exercise of the
+     rights granted or affirmed under this License.  For example, you
+     may not impose a license fee, royalty, or other charge for
+     exercise of rights granted under this License, and you may not
+     initiate litigation (including a cross-claim or counterclaim in a
+     lawsuit) alleging that any patent claim is infringed by making,
+     using, selling, offering for sale, or importing the Program or any
+     portion of it.
+
+ 11. Patents.
+
+     A "contributor" is a copyright holder who authorizes use under this
+     License of the Program or a work on which the Program is based.
+     The work thus licensed is called the contributor's "contributor
+     version".
+
+     A contributor's "essential patent claims" are all patent claims
+     owned or controlled by the contributor, whether already acquired or
+     hereafter acquired, that would be infringed by some manner,
+     permitted by this License, of making, using, or selling its
+     contributor version, but do not include claims that would be
+     infringed only as a consequence of further modification of the
+     contributor version.  For purposes of this definition, "control"
+     includes the right to grant patent sublicenses in a manner
+     consistent with the requirements of this License.
+
+     Each contributor grants you a non-exclusive, worldwide,
+     royalty-free patent license under the contributor's essential
+     patent claims, to make, use, sell, offer for sale, import and
+     otherwise run, modify and propagate the contents of its
+     contributor version.
+
+     In the following three paragraphs, a "patent license" is any
+     express agreement or commitment, however denominated, not to
+     enforce a patent (such as an express permission to practice a
+     patent or covenant not to sue for patent infringement).  To
+     "grant" such a patent license to a party means to make such an
+     agreement or commitment not to enforce a patent against the party.
+
+     If you convey a covered work, knowingly relying on a patent
+     license, and the Corresponding Source of the work is not available
+     for anyone to copy, free of charge and under the terms of this
+     License, through a publicly available network server or other
+     readily accessible means, then you must either (1) cause the
+     Corresponding Source to be so available, or (2) arrange to deprive
+     yourself of the benefit of the patent license for this particular
+     work, or (3) arrange, in a manner consistent with the requirements
+     of this License, to extend the patent license to downstream
+     recipients.  "Knowingly relying" means you have actual knowledge
+     that, but for the patent license, your conveying the covered work
+     in a country, or your recipient's use of the covered work in a
+     country, would infringe one or more identifiable patents in that
+     country that you have reason to believe are valid.
+
+     If, pursuant to or in connection with a single transaction or
+     arrangement, you convey, or propagate by procuring conveyance of, a
+     covered work, and grant a patent license to some of the parties
+     receiving the covered work authorizing them to use, propagate,
+     modify or convey a specific copy of the covered work, then the
+     patent license you grant is automatically extended to all
+     recipients of the covered work and works based on it.
+
+     A patent license is "discriminatory" if it does not include within
+     the scope of its coverage, prohibits the exercise of, or is
+     conditioned on the non-exercise of one or more of the rights that
+     are specifically granted under this License.  You may not convey a
+     covered work if you are a party to an arrangement with a third
+     party that is in the business of distributing software, under
+     which you make payment to the third party based on the extent of
+     your activity of conveying the work, and under which the third
+     party grants, to any of the parties who would receive the covered
+     work from you, a discriminatory patent license (a) in connection
+     with copies of the covered work conveyed by you (or copies made
+     from those copies), or (b) primarily for and in connection with
+     specific products or compilations that contain the covered work,
+     unless you entered into that arrangement, or that patent license
+     was granted, prior to 28 March 2007.
+
+     Nothing in this License shall be construed as excluding or limiting
+     any implied license or other defenses to infringement that may
+     otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+     If conditions are imposed on you (whether by court order,
+     agreement or otherwise) that contradict the conditions of this
+     License, they do not excuse you from the conditions of this
+     License.  If you cannot convey a covered work so as to satisfy
+     simultaneously your obligations under this License and any other
+     pertinent obligations, then as a consequence you may not convey it
+     at all.  For example, if you agree to terms that obligate you to
+     collect a royalty for further conveying from those to whom you
+     convey the Program, the only way you could satisfy both those
+     terms and this License would be to refrain entirely from conveying
+     the Program.
+
+ 13. Use with the GNU Affero General Public License.
+
+     Notwithstanding any other provision of this License, you have
+     permission to link or combine any covered work with a work licensed
+     under version 3 of the GNU Affero General Public License into a
+     single combined work, and to convey the resulting work.  The terms
+     of this License will continue to apply to the part which is the
+     covered work, but the special requirements of the GNU Affero
+     General Public License, section 13, concerning interaction through
+     a network will apply to the combination as such.
+
+ 14. Revised Versions of this License.
+
+     The Free Software Foundation may publish revised and/or new
+     versions of the GNU General Public License from time to time.
+     Such new versions will be similar in spirit to the present
+     version, but may differ in detail to address new problems or
+     concerns.
+
+     Each version is given a distinguishing version number.  If the
+     Program specifies that a certain numbered version of the GNU
+     General Public License "or any later version" applies to it, you
+     have the option of following the terms and conditions either of
+     that numbered version or of any later version published by the
+     Free Software Foundation.  If the Program does not specify a
+     version number of the GNU General Public License, you may choose
+     any version ever published by the Free Software Foundation.
+
+     If the Program specifies that a proxy can decide which future
+     versions of the GNU General Public License can be used, that
+     proxy's public statement of acceptance of a version permanently
+     authorizes you to choose that version for the Program.
+
+     Later license versions may give you additional or different
+     permissions.  However, no additional obligations are imposed on any
+     author or copyright holder as a result of your choosing to follow a
+     later version.
+
+ 15. Disclaimer of Warranty.
+
+     THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+     APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE
+     COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS"
+     WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
+     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE
+     RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.
+     SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
+     NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+     IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+     WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES
+     AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU
+     FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+     CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
+     THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
+     BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+     PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+     PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF
+     THE POSSIBILITY OF SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+     If the disclaimer of warranty and limitation of liability provided
+     above cannot be given local legal effect according to their terms,
+     reviewing courts shall apply local law that most closely
+     approximates an absolute waiver of all civil liability in
+     connection with the Program, unless a warranty or assumption of
+     liability accompanies a copy of the Program in return for a fee.
+
+
+END OF TERMS AND CONDITIONS
+===========================
+
+How to Apply These Terms to Your New Programs
+=============================================
+
+   If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these
+terms.
+
+   To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+     ONE LINE TO GIVE THE PROGRAM'S NAME AND A BRIEF IDEA OF WHAT IT DOES.
+     Copyright (C) YEAR NAME OF AUTHOR
+
+     This program is free software: you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published by
+     the Free Software Foundation, either version 3 of the License, or (at
+     your option) any later version.
+
+     This program is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with this program.  If not, see `http://www.gnu.org/licenses/'.
+
+   Also add information on how to contact you by electronic and paper
+mail.
+
+   If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+     PROGRAM Copyright (C) YEAR NAME OF AUTHOR
+     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+     This is free software, and you are welcome to redistribute it
+     under certain conditions; type `show c' for details.
+
+   The hypothetical commands `show w' and `show c' should show the
+appropriate parts of the General Public License.  Of course, your
+program's commands might be different; for a GUI interface, you would
+use an "about box".
+
+   You should also get your employer (if you work as a programmer) or
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  For more information on this, and how to apply and follow
+the GNU GPL, see `http://www.gnu.org/licenses/'.
+
+   The GNU General Public License does not permit incorporating your
+program into proprietary programs.  If your program is a subroutine
+library, you may consider it more useful to permit linking proprietary
+applications with the library.  If this is what you want to do, use the
+GNU Lesser General Public License instead of this License.  But first,
+please read `http://www.gnu.org/philosophy/why-not-lgpl.html'.
+
+
+File: libunistring.info,  Node: GNU LGPL,  Next: GNU FDL,  Prev: GNU GPL,  Up: Licenses
+
+A.2 GNU LESSER GENERAL PUBLIC LICENSE
+=====================================
+
+                        Version 3, 29 June 2007
+
+     Copyright (C) 2007 Free Software Foundation, Inc. `http://fsf.org/'
+
+     Everyone is permitted to copy and distribute verbatim copies of this
+     license document, but changing it is not allowed.
+
+   This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+     As used herein, "this License" refers to version 3 of the GNU
+     Lesser General Public License, and the "GNU GPL" refers to version
+     3 of the GNU General Public License.
+
+     "The Library" refers to a covered work governed by this License,
+     other than an Application or a Combined Work as defined below.
+
+     An "Application" is any work that makes use of an interface
+     provided by the Library, but which is not otherwise based on the
+     Library.  Defining a subclass of a class defined by the Library is
+     deemed a mode of using an interface provided by the Library.
+
+     A "Combined Work" is a work produced by combining or linking an
+     Application with the Library.  The particular version of the
+     Library with which the Combined Work was made is also called the
+     "Linked Version".
+
+     The "Minimal Corresponding Source" for a Combined Work means the
+     Corresponding Source for the Combined Work, excluding any source
+     code for portions of the Combined Work that, considered in
+     isolation, are based on the Application, and not on the Linked
+     Version.
+
+     The "Corresponding Application Code" for a Combined Work means the
+     object code and/or source code for the Application, including any
+     data and utility programs needed for reproducing the Combined Work
+     from the Application, but excluding the System Libraries of the
+     Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+     You may convey a covered work under sections 3 and 4 of this
+     License without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+     If you modify a copy of the Library, and, in your modifications, a
+     facility refers to a function or data to be supplied by an
+     Application that uses the facility (other than as an argument
+     passed when the facility is invoked), then you may convey a copy
+     of the modified version:
+
+       a. under this License, provided that you make a good faith
+          effort to ensure that, in the event an Application does not
+          supply the function or data, the facility still operates, and
+          performs whatever part of its purpose remains meaningful, or
+
+       b. under the GNU GPL, with none of the additional permissions of
+          this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+     The object code form of an Application may incorporate material
+     from a header file that is part of the Library.  You may convey
+     such object code under terms of your choice, provided that, if the
+     incorporated material is not limited to numerical parameters, data
+     structure layouts and accessors, or small macros, inline functions
+     and templates (ten or fewer lines in length), you do both of the
+     following:
+
+       a. Give prominent notice with each copy of the object code that
+          the Library is used in it and that the Library and its use are
+          covered by this License.
+
+       b. Accompany the object code with a copy of the GNU GPL and this
+          license document.
+
+  4. Combined Works.
+
+     You may convey a Combined Work under terms of your choice that,
+     taken together, effectively do not restrict modification of the
+     portions of the Library contained in the Combined Work and reverse
+     engineering for debugging such modifications, if you also do each
+     of the following:
+
+       a. Give prominent notice with each copy of the Combined Work that
+          the Library is used in it and that the Library and its use are
+          covered by this License.
+
+       b. Accompany the Combined Work with a copy of the GNU GPL and
+          this license document.
+
+       c. For a Combined Work that displays copyright notices during
+          execution, include the copyright notice for the Library among
+          these notices, as well as a reference directing the user to
+          the copies of the GNU GPL and this license document.
+
+       d. Do one of the following:
+
+            0. Convey the Minimal Corresponding Source under the terms
+               of this License, and the Corresponding Application Code
+               in a form suitable for, and under terms that permit, the
+               user to recombine or relink the Application with a
+               modified version of the Linked Version to produce a
+               modified Combined Work, in the manner specified by
+               section 6 of the GNU GPL for conveying Corresponding
+               Source.
+
+            1. Use a suitable shared library mechanism for linking with
+               the Library.  A suitable mechanism is one that (a) uses
+               at run time a copy of the Library already present on the
+               user's computer system, and (b) will operate properly
+               with a modified version of the Library that is
+               interface-compatible with the Linked Version.
+
+       e. Provide Installation Information, but only if you would
+          otherwise be required to provide such information under
+          section 6 of the GNU GPL, and only to the extent that such
+          information is necessary to install and execute a modified
+          version of the Combined Work produced by recombining or
+          relinking the Application with a modified version of the
+          Linked Version. (If you use option 4d0, the Installation
+          Information must accompany the Minimal Corresponding Source
+          and Corresponding Application Code. If you use option 4d1,
+          you must provide the Installation Information in the manner
+          specified by section 6 of the GNU GPL for conveying
+          Corresponding Source.)
+
+  5. Combined Libraries.
+
+     You may place library facilities that are a work based on the
+     Library side by side in a single library together with other
+     library facilities that are not Applications and are not covered
+     by this License, and convey such a combined library under terms of
+     your choice, if you do both of the following:
+
+       a. Accompany the combined library with a copy of the same work
+          based on the Library, uncombined with any other library
+          facilities, conveyed under the terms of this License.
+
+       b. Give prominent notice with the combined library that part of
+          it is a work based on the Library, and explaining where to
+          find the accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+     The Free Software Foundation may publish revised and/or new
+     versions of the GNU Lesser General Public License from time to
+     time. Such new versions will be similar in spirit to the present
+     version, but may differ in detail to address new problems or
+     concerns.
+
+     Each version is given a distinguishing version number. If the
+     Library as you received it specifies that a certain numbered
+     version of the GNU Lesser General Public License "or any later
+     version" applies to it, you have the option of following the terms
+     and conditions either of that published version or of any later
+     version published by the Free Software Foundation. If the Library
+     as you received it does not specify a version number of the GNU
+     Lesser General Public License, you may choose any version of the
+     GNU Lesser General Public License ever published by the Free
+     Software Foundation.
+
+     If the Library as you received it specifies that a proxy can decide
+     whether future versions of the GNU Lesser General Public License
+     shall apply, that proxy's public statement of acceptance of any
+     version is permanent authorization for you to choose that version
+     for the Library.
+
+
+
+File: libunistring.info,  Node: GNU FDL,  Prev: GNU LGPL,  Up: Licenses
+
+A.3 GNU Free Documentation License
+==================================
+
+                     Version 1.3, 3 November 2008
+
+     Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
+     `http://fsf.org/'
+
+     Everyone is permitted to copy and distribute verbatim copies
+     of this license document, but changing it is not allowed.
+
+  0. PREAMBLE
+
+     The purpose of this License is to make a manual, textbook, or other
+     functional and useful document "free" in the sense of freedom: to
+     assure everyone the effective freedom to copy and redistribute it,
+     with or without modifying it, either commercially or
+     noncommercially.  Secondarily, this License preserves for the
+     author and publisher a way to get credit for their work, while not
+     being considered responsible for modifications made by others.
+
+     This License is a kind of "copyleft", which means that derivative
+     works of the document must themselves be free in the same sense.
+     It complements the GNU General Public License, which is a copyleft
+     license designed for free software.
+
+     We have designed this License in order to use it for manuals for
+     free software, because free software needs free documentation: a
+     free program should come with manuals providing the same freedoms
+     that the software does.  But this License is not limited to
+     software manuals; it can be used for any textual work, regardless
+     of subject matter or whether it is published as a printed book.
+     We recommend this License principally for works whose purpose is
+     instruction or reference.
+
+  1. APPLICABILITY AND DEFINITIONS
+
+     This License applies to any manual or other work, in any medium,
+     that contains a notice placed by the copyright holder saying it
+     can be distributed under the terms of this License.  Such a notice
+     grants a world-wide, royalty-free license, unlimited in duration,
+     to use that work under the conditions stated herein.  The
+     "Document", below, refers to any such manual or work.  Any member
+     of the public is a licensee, and is addressed as "you".  You
+     accept the license if you copy, modify or distribute the work in a
+     way requiring permission under copyright law.
+
+     A "Modified Version" of the Document means any work containing the
+     Document or a portion of it, either copied verbatim, or with
+     modifications and/or translated into another language.
+
+     A "Secondary Section" is a named appendix or a front-matter section
+     of the Document that deals exclusively with the relationship of the
+     publishers or authors of the Document to the Document's overall
+     subject (or to related matters) and contains nothing that could
+     fall directly within that overall subject.  (Thus, if the Document
+     is in part a textbook of mathematics, a Secondary Section may not
+     explain any mathematics.)  The relationship could be a matter of
+     historical connection with the subject or with related matters, or
+     of legal, commercial, philosophical, ethical or political position
+     regarding them.
+
+     The "Invariant Sections" are certain Secondary Sections whose
+     titles are designated, as being those of Invariant Sections, in
+     the notice that says that the Document is released under this
+     License.  If a section does not fit the above definition of
+     Secondary then it is not allowed to be designated as Invariant.
+     The Document may contain zero Invariant Sections.  If the Document
+     does not identify any Invariant Sections then there are none.
+
+     The "Cover Texts" are certain short passages of text that are
+     listed, as Front-Cover Texts or Back-Cover Texts, in the notice
+     that says that the Document is released under this License.  A
+     Front-Cover Text may be at most 5 words, and a Back-Cover Text may
+     be at most 25 words.
+
+     A "Transparent" copy of the Document means a machine-readable copy,
+     represented in a format whose specification is available to the
+     general public, that is suitable for revising the document
+     straightforwardly with generic text editors or (for images
+     composed of pixels) generic paint programs or (for drawings) some
+     widely available drawing editor, and that is suitable for input to
+     text formatters or for automatic translation to a variety of
+     formats suitable for input to text formatters.  A copy made in an
+     otherwise Transparent file format whose markup, or absence of
+     markup, has been arranged to thwart or discourage subsequent
+     modification by readers is not Transparent.  An image format is
+     not Transparent if used for any substantial amount of text.  A
+     copy that is not "Transparent" is called "Opaque".
+
+     Examples of suitable formats for Transparent copies include plain
+     ASCII without markup, Texinfo input format, LaTeX input format,
+     SGML or XML using a publicly available DTD, and
+     standard-conforming simple HTML, PostScript or PDF designed for
+     human modification.  Examples of transparent image formats include
+     PNG, XCF and JPG.  Opaque formats include proprietary formats that
+     can be read and edited only by proprietary word processors, SGML or
+     XML for which the DTD and/or processing tools are not generally
+     available, and the machine-generated HTML, PostScript or PDF
+     produced by some word processors for output purposes only.
+
+     The "Title Page" means, for a printed book, the title page itself,
+     plus such following pages as are needed to hold, legibly, the
+     material this License requires to appear in the title page.  For
+     works in formats which do not have any title page as such, "Title
+     Page" means the text near the most prominent appearance of the
+     work's title, preceding the beginning of the body of the text.
+
+     The "publisher" means any person or entity that distributes copies
+     of the Document to the public.
+
+     A section "Entitled XYZ" means a named subunit of the Document
+     whose title either is precisely XYZ or contains XYZ in parentheses
+     following text that translates XYZ in another language.  (Here XYZ
+     stands for a specific section name mentioned below, such as
+     "Acknowledgements", "Dedications", "Endorsements", or "History".)
+     To "Preserve the Title" of such a section when you modify the
+     Document means that it remains a section "Entitled XYZ" according
+     to this definition.
+
+     The Document may include Warranty Disclaimers next to the notice
+     which states that this License applies to the Document.  These
+     Warranty Disclaimers are considered to be included by reference in
+     this License, but only as regards disclaiming warranties: any other
+     implication that these Warranty Disclaimers may have is void and
+     has no effect on the meaning of this License.
+
+  2. VERBATIM COPYING
+
+     You may copy and distribute the Document in any medium, either
+     commercially or noncommercially, provided that this License, the
+     copyright notices, and the license notice saying this License
+     applies to the Document are reproduced in all copies, and that you
+     add no other conditions whatsoever to those of this License.  You
+     may not use technical measures to obstruct or control the reading
+     or further copying of the copies you make or distribute.  However,
+     you may accept compensation in exchange for copies.  If you
+     distribute a large enough number of copies you must also follow
+     the conditions in section 3.
+
+     You may also lend copies, under the same conditions stated above,
+     and you may publicly display copies.
+
+  3. COPYING IN QUANTITY
+
+     If you publish printed copies (or copies in media that commonly
+     have printed covers) of the Document, numbering more than 100, and
+     the Document's license notice requires Cover Texts, you must
+     enclose the copies in covers that carry, clearly and legibly, all
+     these Cover Texts: Front-Cover Texts on the front cover, and
+     Back-Cover Texts on the back cover.  Both covers must also clearly
+     and legibly identify you as the publisher of these copies.  The
+     front cover must present the full title with all words of the
+     title equally prominent and visible.  You may add other material
+     on the covers in addition.  Copying with changes limited to the
+     covers, as long as they preserve the title of the Document and
+     satisfy these conditions, can be treated as verbatim copying in
+     other respects.
+
+     If the required texts for either cover are too voluminous to fit
+     legibly, you should put the first ones listed (as many as fit
+     reasonably) on the actual cover, and continue the rest onto
+     adjacent pages.
+
+     If you publish or distribute Opaque copies of the Document
+     numbering more than 100, you must either include a
+     machine-readable Transparent copy along with each Opaque copy, or
+     state in or with each Opaque copy a computer-network location from
+     which the general network-using public has access to download
+     using public-standard network protocols a complete Transparent
+     copy of the Document, free of added material.  If you use the
+     latter option, you must take reasonably prudent steps, when you
+     begin distribution of Opaque copies in quantity, to ensure that
+     this Transparent copy will remain thus accessible at the stated
+     location until at least one year after the last time you
+     distribute an Opaque copy (directly or through your agents or
+     retailers) of that edition to the public.
+
+     It is requested, but not required, that you contact the authors of
+     the Document well before redistributing any large number of
+     copies, to give them a chance to provide you with an updated
+     version of the Document.
+
+  4. MODIFICATIONS
+
+     You may copy and distribute a Modified Version of the Document
+     under the conditions of sections 2 and 3 above, provided that you
+     release the Modified Version under precisely this License, with
+     the Modified Version filling the role of the Document, thus
+     licensing distribution and modification of the Modified Version to
+     whoever possesses a copy of it.  In addition, you must do these
+     things in the Modified Version:
+
+       A. Use in the Title Page (and on the covers, if any) a title
+          distinct from that of the Document, and from those of
+          previous versions (which should, if there were any, be listed
+          in the History section of the Document).  You may use the
+          same title as a previous version if the original publisher of
+          that version gives permission.
+
+       B. List on the Title Page, as authors, one or more persons or
+          entities responsible for authorship of the modifications in
+          the Modified Version, together with at least five of the
+          principal authors of the Document (all of its principal
+          authors, if it has fewer than five), unless they release you
+          from this requirement.
+
+       C. State on the Title page the name of the publisher of the
+          Modified Version, as the publisher.
+
+       D. Preserve all the copyright notices of the Document.
+
+       E. Add an appropriate copyright notice for your modifications
+          adjacent to the other copyright notices.
+
+       F. Include, immediately after the copyright notices, a license
+          notice giving the public permission to use the Modified
+          Version under the terms of this License, in the form shown in
+          the Addendum below.
+
+       G. Preserve in that license notice the full lists of Invariant
+          Sections and required Cover Texts given in the Document's
+          license notice.
+
+       H. Include an unaltered copy of this License.
+
+       I. Preserve the section Entitled "History", Preserve its Title,
+          and add to it an item stating at least the title, year, new
+          authors, and publisher of the Modified Version as given on
+          the Title Page.  If there is no section Entitled "History" in
+          the Document, create one stating the title, year, authors,
+          and publisher of the Document as given on its Title Page,
+          then add an item describing the Modified Version as stated in
+          the previous sentence.
+
+       J. Preserve the network location, if any, given in the Document
+          for public access to a Transparent copy of the Document, and
+          likewise the network locations given in the Document for
+          previous versions it was based on.  These may be placed in
+          the "History" section.  You may omit a network location for a
+          work that was published at least four years before the
+          Document itself, or if the original publisher of the version
+          it refers to gives permission.
+
+       K. For any section Entitled "Acknowledgements" or "Dedications",
+          Preserve the Title of the section, and preserve in the
+          section all the substance and tone of each of the contributor
+          acknowledgements and/or dedications given therein.
+
+       L. Preserve all the Invariant Sections of the Document,
+          unaltered in their text and in their titles.  Section numbers
+          or the equivalent are not considered part of the section
+          titles.
+
+       M. Delete any section Entitled "Endorsements".  Such a section
+          may not be included in the Modified Version.
+
+       N. Do not retitle any existing section to be Entitled
+          "Endorsements" or to conflict in title with any Invariant
+          Section.
+
+       O. Preserve any Warranty Disclaimers.
+
+     If the Modified Version includes new front-matter sections or
+     appendices that qualify as Secondary Sections and contain no
+     material copied from the Document, you may at your option
+     designate some or all of these sections as invariant.  To do this,
+     add their titles to the list of Invariant Sections in the Modified
+     Version's license notice.  These titles must be distinct from any
+     other section titles.
+
+     You may add a section Entitled "Endorsements", provided it contains
+     nothing but endorsements of your Modified Version by various
+     parties--for example, statements of peer review or that the text
+     has been approved by an organization as the authoritative
+     definition of a standard.
+
+     You may add a passage of up to five words as a Front-Cover Text,
+     and a passage of up to 25 words as a Back-Cover Text, to the end
+     of the list of Cover Texts in the Modified Version.  Only one
+     passage of Front-Cover Text and one of Back-Cover Text may be
+     added by (or through arrangements made by) any one entity.  If the
+     Document already includes a cover text for the same cover,
+     previously added by you or by arrangement made by the same entity
+     you are acting on behalf of, you may not add another; but you may
+     replace the old one, on explicit permission from the previous
+     publisher that added the old one.
+
+     The author(s) and publisher(s) of the Document do not by this
+     License give permission to use their names for publicity for or to
+     assert or imply endorsement of any Modified Version.
+
+  5. COMBINING DOCUMENTS
+
+     You may combine the Document with other documents released under
+     this License, under the terms defined in section 4 above for
+     modified versions, provided that you include in the combination
+     all of the Invariant Sections of all of the original documents,
+     unmodified, and list them all as Invariant Sections of your
+     combined work in its license notice, and that you preserve all
+     their Warranty Disclaimers.
+
+     The combined work need only contain one copy of this License, and
+     multiple identical Invariant Sections may be replaced with a single
+     copy.  If there are multiple Invariant Sections with the same name
+     but different contents, make the title of each such section unique
+     by adding at the end of it, in parentheses, the name of the
+     original author or publisher of that section if known, or else a
+     unique number.  Make the same adjustment to the section titles in
+     the list of Invariant Sections in the license notice of the
+     combined work.
+
+     In the combination, you must combine any sections Entitled
+     "History" in the various original documents, forming one section
+     Entitled "History"; likewise combine any sections Entitled
+     "Acknowledgements", and any sections Entitled "Dedications".  You
+     must delete all sections Entitled "Endorsements."
+
+  6. COLLECTIONS OF DOCUMENTS
+
+     You may make a collection consisting of the Document and other
+     documents released under this License, and replace the individual
+     copies of this License in the various documents with a single copy
+     that is included in the collection, provided that you follow the
+     rules of this License for verbatim copying of each of the
+     documents in all other respects.
+
+     You may extract a single document from such a collection, and
+     distribute it individually under this License, provided you insert
+     a copy of this License into the extracted document, and follow
+     this License in all other respects regarding verbatim copying of
+     that document.
+
+  7. AGGREGATION WITH INDEPENDENT WORKS
+
+     A compilation of the Document or its derivatives with other
+     separate and independent documents or works, in or on a volume of
+     a storage or distribution medium, is called an "aggregate" if the
+     copyright resulting from the compilation is not used to limit the
+     legal rights of the compilation's users beyond what the individual
+     works permit.  When the Document is included in an aggregate, this
+     License does not apply to the other works in the aggregate which
+     are not themselves derivative works of the Document.
+
+     If the Cover Text requirement of section 3 is applicable to these
+     copies of the Document, then if the Document is less than one half
+     of the entire aggregate, the Document's Cover Texts may be placed
+     on covers that bracket the Document within the aggregate, or the
+     electronic equivalent of covers if the Document is in electronic
+     form.  Otherwise they must appear on printed covers that bracket
+     the whole aggregate.
+
+  8. TRANSLATION
+
+     Translation is considered a kind of modification, so you may
+     distribute translations of the Document under the terms of section
+     4.  Replacing Invariant Sections with translations requires special
+     permission from their copyright holders, but you may include
+     translations of some or all Invariant Sections in addition to the
+     original versions of these Invariant Sections.  You may include a
+     translation of this License, and all the license notices in the
+     Document, and any Warranty Disclaimers, provided that you also
+     include the original English version of this License and the
+     original versions of those notices and disclaimers.  In case of a
+     disagreement between the translation and the original version of
+     this License or a notice or disclaimer, the original version will
+     prevail.
+
+     If a section in the Document is Entitled "Acknowledgements",
+     "Dedications", or "History", the requirement (section 4) to
+     Preserve its Title (section 1) will typically require changing the
+     actual title.
+
+  9. TERMINATION
+
+     You may not copy, modify, sublicense, or distribute the Document
+     except as expressly provided under this License.  Any attempt
+     otherwise to copy, modify, sublicense, or distribute it is void,
+     and will automatically terminate your rights under this License.
+
+     However, if you cease all violation of this License, then your
+     license from a particular copyright holder is reinstated (a)
+     provisionally, unless and until the copyright holder explicitly
+     and finally terminates your license, and (b) permanently, if the
+     copyright holder fails to notify you of the violation by some
+     reasonable means prior to 60 days after the cessation.
+
+     Moreover, your license from a particular copyright holder is
+     reinstated permanently if the copyright holder notifies you of the
+     violation by some reasonable means, this is the first time you have
+     received notice of violation of this License (for any work) from
+     that copyright holder, and you cure the violation prior to 30 days
+     after your receipt of the notice.
+
+     Termination of your rights under this section does not terminate
+     the licenses of parties who have received copies or rights from
+     you under this License.  If your rights have been terminated and
+     not permanently reinstated, receipt of a copy of some or all of
+     the same material does not give you any rights to use it.
+
+ 10. FUTURE REVISIONS OF THIS LICENSE
+
+     The Free Software Foundation may publish new, revised versions of
+     the GNU Free Documentation License from time to time.  Such new
+     versions will be similar in spirit to the present version, but may
+     differ in detail to address new problems or concerns.  See
+     `http://www.gnu.org/copyleft/'.
+
+     Each version of the License is given a distinguishing version
+     number.  If the Document specifies that a particular numbered
+     version of this License "or any later version" applies to it, you
+     have the option of following the terms and conditions either of
+     that specified version or of any later version that has been
+     published (not as a draft) by the Free Software Foundation.  If
+     the Document does not specify a version number of this License,
+     you may choose any version ever published (not as a draft) by the
+     Free Software Foundation.  If the Document specifies that a proxy
+     can decide which future versions of this License can be used, that
+     proxy's public statement of acceptance of a version permanently
+     authorizes you to choose that version for the Document.
+
+ 11. RELICENSING
+
+     "Massive Multiauthor Collaboration Site" (or "MMC Site") means any
+     World Wide Web server that publishes copyrightable works and also
+     provides prominent facilities for anybody to edit those works.  A
+     public wiki that anybody can edit is an example of such a server.
+     A "Massive Multiauthor Collaboration" (or "MMC") contained in the
+     site means any set of copyrightable works thus published on the MMC
+     site.
+
+     "CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0
+     license published by Creative Commons Corporation, a not-for-profit
+     corporation with a principal place of business in San Francisco,
+     California, as well as future copyleft versions of that license
+     published by that same organization.
+
+     "Incorporate" means to publish or republish a Document, in whole or
+     in part, as part of another Document.
+
+     An MMC is "eligible for relicensing" if it is licensed under this
+     License, and if all works that were first published under this
+     License somewhere other than this MMC, and subsequently
+     incorporated in whole or in part into the MMC, (1) had no cover
+     texts or invariant sections, and (2) were thus incorporated prior
+     to November 1, 2008.
+
+     The operator of an MMC Site may republish an MMC contained in the
+     site under CC-BY-SA on the same site at any time before August 1,
+     2009, provided the MMC is eligible for relicensing.
+
+
+ADDENDUM: How to use this License for your documents
+====================================================
+
+   To use this License in a document you have written, include a copy of
+the License in the document and put the following copyright and license
+notices just after the title page:
+
+       Copyright (C)  YEAR  YOUR NAME.
+       Permission is granted to copy, distribute and/or modify this document
+       under the terms of the GNU Free Documentation License, Version 1.3
+       or any later version published by the Free Software Foundation;
+       with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
+       Texts.  A copy of the license is included in the section entitled ``GNU
+       Free Documentation License''.
+
+   If you have Invariant Sections, Front-Cover Texts and Back-Cover
+Texts, replace the "with...Texts." line with this:
+
+         with the Invariant Sections being LIST THEIR TITLES, with
+         the Front-Cover Texts being LIST, and with the Back-Cover Texts
+         being LIST.
+
+   If you have Invariant Sections without Cover Texts, or some other
+combination of the three, merge those two alternatives to suit the
+situation.
+
+   If your document contains nontrivial examples of program code, we
+recommend releasing these examples in parallel under your choice of
+free software license, such as the GNU General Public License, to
+permit their use in free software.
+
+
+File: libunistring.info,  Node: Index,  Prev: Licenses,  Up: Top
+
+Index
+*****
+
+
+* Menu:
+
+* ambiguous width:                       uniwidth.h.          (line  10)
+* argument conventions:                  Conventions.         (line   9)
+* autoconf macro:                        Autoconf macro.      (line   6)
+* bidirectional category:                Bidirectional category.
+                                                              (line   6)
+* bidirectional reordering:              More functionality.  (line   6)
+* block:                                 Blocks.              (line   6)
+* breaks, line:                          unilbrk.h.           (line   6)
+* breaks, word:                          uniwbrk.h.           (line   6)
+* bug reports:                           Reporting problems.  (line   6)
+* bug tracker:                           Reporting problems.  (line   6)
+* C string functions:                    char * strings.      (line   6)
+* C, programming language:               ISO C and Java syntax.
+                                                              (line   6)
+* C-like API:                            Classifications like in ISO C.
+                                                              (line   6)
+* canonical combining class:             Canonical combining class.
+                                                              (line   6)
+* case detection:                        Case detection.      (line   6)
+* case mappings:                         Case mappings of strings.
+                                                              (line   6)
+* casing_prefix_context_t:               Case mappings of substrings.
+                                                              (line  15)
+* casing_suffix_context_t:               Case mappings of substrings.
+                                                              (line  46)
+* char, type:                            char * strings.      (line  23)
+* combining, Unicode characters:         Composition of characters.
+                                                              (line   6)
+* comparing <1>:                         Elementary string functions on NUL terminated strings.
+                                                              (line 128)
+* comparing:                             Elementary string functions.
+                                                              (line 108)
+* comparing, ignoring case:              Case insensitive comparison.
+                                                              (line   6)
+* comparing, ignoring case, with collation rules: Case insensitive comparison.
+                                                              (line  66)
+* comparing, ignoring normalization:     Normalizing comparisons.
+                                                              (line   6)
+* comparing, ignoring normalization and case: Case insensitive comparison.
+                                                              (line   6)
+* comparing, ignoring normalization and case, with collation rules: Case insensitive comparison.
+                                                              (line  66)
+* comparing, ignoring normalization, with collation rules: Normalizing comparisons.
+                                                              (line  23)
+* comparing, with collation rules:       Elementary string functions on NUL terminated strings.
+                                                              (line 140)
+* comparing, with collation rules, ignoring case: Case insensitive comparison.
+                                                              (line  66)
+* comparing, with collation rules, ignoring normalization: Normalizing comparisons.
+                                                              (line  23)
+* comparing, with collation rules, ignoring normalization and case: Case insensitive comparison.
+                                                              (line  66)
+* compiler options:                      Compiler options.    (line  24)
+* composing, Unicode characters:         Composition of characters.
+                                                              (line   6)
+* converting <1>:                        uniconv.h.           (line  45)
+* converting:                            Elementary string conversions.
+                                                              (line   6)
+* copying <1>:                           Elementary string functions on NUL terminated strings.
+                                                              (line  61)
+* copying:                               Elementary string functions.
+                                                              (line  72)
+* counting:                              Elementary string functions.
+                                                              (line 153)
+* decomposing:                           Decomposition of characters.
+                                                              (line   6)
+* dependencies:                          Installation.        (line   6)
+* detecting case:                        Case detection.      (line   6)
+* duplicating <1>:                       Elementary string functions on NUL terminated strings.
+                                                              (line 166)
+* duplicating:                           Elementary string functions with memory allocation.
+                                                              (line   6)
+* enum iconv_ilseq_handler:              uniconv.h.           (line  30)
+* FDL, GNU Free Documentation License:   GNU FDL.             (line   6)
+* formatted output:                      unistdio.h.          (line   6)
+* fullwidth:                             uniwidth.h.          (line  22)
+* general category:                      General category.    (line   6)
+* gl_LIBUNISTRING:                       Autoconf macro.      (line  11)
+* GPL, GNU General Public License:       GNU GPL.             (line   6)
+* halfwidth:                             uniwidth.h.          (line  22)
+* identifiers:                           ISO C and Java syntax.
+                                                              (line   6)
+* installation:                          Installation.        (line  10)
+* internationalization:                  Unicode and i18n.    (line   6)
+* iterating <1>:                         Elementary string functions on NUL terminated strings.
+                                                              (line  15)
+* iterating:                             Elementary string functions.
+                                                              (line   6)
+* Java, programming language:            ISO C and Java syntax.
+                                                              (line   6)
+* LGPL, GNU Lesser General Public License: GNU LGPL.          (line   6)
+* License, GNU FDL:                      GNU FDL.             (line   6)
+* License, GNU GPL:                      GNU GPL.             (line   6)
+* License, GNU LGPL:                     GNU LGPL.            (line   6)
+* Licenses:                              Licenses.            (line   6)
+* line breaks:                           unilbrk.h.           (line   6)
+* locale:                                Locale encodings.    (line   6)
+* locale categories:                     Locale encodings.    (line  10)
+* locale encoding <1>:                   uniconv.h.           (line  10)
+* locale encoding:                       Locale encodings.    (line  28)
+* locale language:                       Case mappings of strings.
+                                                              (line  16)
+* locale, multibyte:                     char * strings.      (line  13)
+* locale_charset:                        uniconv.h.           (line  13)
+* lowercasing:                           Case mappings of strings.
+                                                              (line   6)
+* mailing list:                          Reporting problems.  (line   6)
+* mirroring, of Unicode character:       Mirrored character.  (line   6)
+* normal forms:                          uninorm.h.           (line   6)
+* normalizing:                           uninorm.h.           (line   6)
+* output, formatted:                     unistdio.h.          (line   6)
+* properties, of Unicode character:      Properties.          (line   6)
+* regular expression:                    uniregex.h.          (line   6)
+* rendering:                             More functionality.  (line   9)
+* return value conventions:              Conventions.         (line  47)
+* scripts:                               Scripts.             (line   6)
+* searching, for a character <1>:        Elementary string functions on NUL terminated strings.
+                                                              (line 176)
+* searching, for a character:            Elementary string functions.
+                                                              (line 140)
+* searching, for a substring:            Elementary string functions on NUL terminated strings.
+                                                              (line 232)
+* stream, normalizing a:                 Normalization of streams.
+                                                              (line   6)
+* struct uninorm_filter:                 Normalization of streams.
+                                                              (line  11)
+* titlecasing:                           Case mappings of strings.
+                                                              (line   6)
+* u16_asnprintf:                         unistdio.h.          (line 132)
+* u16_asprintf:                          unistdio.h.          (line 129)
+* u16_casecmp:                           Case insensitive comparison.
+                                                              (line  51)
+* u16_casecoll:                          Case insensitive comparison.
+                                                              (line  95)
+* u16_casefold:                          Case insensitive comparison.
+                                                              (line  15)
+* u16_casexfrm:                          Case insensitive comparison.
+                                                              (line  75)
+* u16_casing_prefix_context:             Case mappings of substrings.
+                                                              (line  30)
+* u16_casing_prefixes_context:           Case mappings of substrings.
+                                                              (line  39)
+* u16_casing_suffix_context:             Case mappings of substrings.
+                                                              (line  61)
+* u16_casing_suffixes_context:           Case mappings of substrings.
+                                                              (line  70)
+* u16_check:                             Elementary string checks.
+                                                              (line  11)
+* u16_chr:                               Elementary string functions.
+                                                              (line 145)
+* u16_cmp:                               Elementary string functions.
+                                                              (line 115)
+* u16_cmp2:                              Elementary string functions.
+                                                              (line 131)
+* u16_conv_from_encoding:                uniconv.h.           (line  54)
+* u16_conv_to_encoding:                  uniconv.h.           (line  91)
+* u16_cpy:                               Elementary string functions.
+                                                              (line  78)
+* u16_cpy_alloc:                         Elementary string functions with memory allocation.
+                                                              (line  10)
+* u16_ct_casefold:                       Case insensitive comparison.
+                                                              (line  37)
+* u16_ct_tolower:                        Case mappings of substrings.
+                                                              (line 107)
+* u16_ct_totitle:                        Case mappings of substrings.
+                                                              (line 125)
+* u16_ct_toupper:                        Case mappings of substrings.
+                                                              (line  89)
+* u16_endswith:                          Elementary string functions on NUL terminated strings.
+                                                              (line 258)
+* u16_is_cased:                          Case detection.      (line  57)
+* u16_is_casefolded:                     Case detection.      (line  44)
+* u16_is_lowercase:                      Case detection.      (line  24)
+* u16_is_titlecase:                      Case detection.      (line  34)
+* u16_is_uppercase:                      Case detection.      (line  14)
+* u16_mblen:                             Elementary string functions.
+                                                              (line  11)
+* u16_mbsnlen:                           Elementary string functions.
+                                                              (line 157)
+* u16_mbtouc:                            Elementary string functions.
+                                                              (line  38)
+* u16_mbtouc_unsafe:                     Elementary string functions.
+                                                              (line  23)
+* u16_mbtoucr:                           Elementary string functions.
+                                                              (line  45)
+* u16_move:                              Elementary string functions.
+                                                              (line  89)
+* u16_next:                              Elementary string functions on NUL terminated strings.
+                                                              (line  24)
+* u16_normalize:                         Normalization of strings.
+                                                              (line  50)
+* u16_normcmp:                           Normalizing comparisons.
+                                                              (line  13)
+* u16_normcoll:                          Normalizing comparisons.
+                                                              (line  40)
+* u16_normxfrm:                          Normalizing comparisons.
+                                                              (line  27)
+* u16_possible_linebreaks:               unilbrk.h.           (line  46)
+* u16_prev:                              Elementary string functions on NUL terminated strings.
+                                                              (line  36)
+* u16_set:                               Elementary string functions.
+                                                              (line 101)
+* u16_snprintf:                          unistdio.h.          (line 126)
+* u16_sprintf:                           unistdio.h.          (line 123)
+* u16_startswith:                        Elementary string functions on NUL terminated strings.
+                                                              (line 250)
+* u16_stpcpy:                            Elementary string functions on NUL terminated strings.
+                                                              (line  76)
+* u16_stpncpy:                           Elementary string functions on NUL terminated strings.
+                                                              (line  99)
+* u16_strcat:                            Elementary string functions on NUL terminated strings.
+                                                              (line 110)
+* u16_strchr:                            Elementary string functions on NUL terminated strings.
+                                                              (line 180)
+* u16_strcmp:                            Elementary string functions on NUL terminated strings.
+                                                              (line 132)
+* u16_strcoll:                           Elementary string functions on NUL terminated strings.
+                                                              (line 142)
+* u16_strconv_from_encoding:             uniconv.h.           (line 129)
+* u16_strconv_from_locale:               uniconv.h.           (line 157)
+* u16_strconv_to_encoding:               uniconv.h.           (line 142)
+* u16_strconv_to_locale:                 uniconv.h.           (line 167)
+* u16_strcpy:                            Elementary string functions on NUL terminated strings.
+                                                              (line  66)
+* u16_strcspn:                           Elementary string functions on NUL terminated strings.
+                                                              (line 201)
+* u16_strdup:                            Elementary string functions on NUL terminated strings.
+                                                              (line 170)
+* u16_strlen:                            Elementary string functions on NUL terminated strings.
+                                                              (line  47)
+* u16_strmblen:                          Elementary string functions on NUL terminated strings.
+                                                              (line  11)
+* u16_strmbtouc:                         Elementary string functions on NUL terminated strings.
+                                                              (line  17)
+* u16_strncat:                           Elementary string functions on NUL terminated strings.
+                                                              (line 121)
+* u16_strncmp:                           Elementary string functions on NUL terminated strings.
+                                                              (line 159)
+* u16_strncpy:                           Elementary string functions on NUL terminated strings.
+                                                              (line  88)
+* u16_strnlen:                           Elementary string functions on NUL terminated strings.
+                                                              (line  55)
+* u16_strpbrk:                           Elementary string functions on NUL terminated strings.
+                                                              (line 225)
+* u16_strrchr:                           Elementary string functions on NUL terminated strings.
+                                                              (line 188)
+* u16_strspn:                            Elementary string functions on NUL terminated strings.
+                                                              (line 213)
+* u16_strstr:                            Elementary string functions on NUL terminated strings.
+                                                              (line 239)
+* u16_strtok:                            Elementary string functions on NUL terminated strings.
+                                                              (line 268)
+* u16_strwidth:                          uniwidth.h.          (line  39)
+* u16_to_u32:                            Elementary string conversions.
+                                                              (line  23)
+* u16_to_u8:                             Elementary string conversions.
+                                                              (line  19)
+* u16_tolower:                           Case mappings of strings.
+                                                              (line  44)
+* u16_totitle:                           Case mappings of strings.
+                                                              (line  58)
+* u16_toupper:                           Case mappings of strings.
+                                                              (line  30)
+* u16_u16_asnprintf:                     unistdio.h.          (line 159)
+* u16_u16_asprintf:                      unistdio.h.          (line 156)
+* u16_u16_snprintf:                      unistdio.h.          (line 153)
+* u16_u16_sprintf:                       unistdio.h.          (line 150)
+* u16_u16_vasnprintf:                    unistdio.h.          (line 171)
+* u16_u16_vasprintf:                     unistdio.h.          (line 168)
+* u16_u16_vsnprintf:                     unistdio.h.          (line 165)
+* u16_u16_vsprintf:                      unistdio.h.          (line 162)
+* u16_uctomb:                            Elementary string functions.
+                                                              (line  62)
+* u16_vasnprintf:                        unistdio.h.          (line 144)
+* u16_vasprintf:                         unistdio.h.          (line 141)
+* u16_vsnprintf:                         unistdio.h.          (line 138)
+* u16_vsprintf:                          unistdio.h.          (line 135)
+* u16_width:                             uniwidth.h.          (line  31)
+* u16_width_linebreaks:                  unilbrk.h.           (line  65)
+* u16_wordbreaks:                        Word breaks in a string.
+                                                              (line  10)
+* u32_asnprintf:                         unistdio.h.          (line 185)
+* u32_asprintf:                          unistdio.h.          (line 182)
+* u32_casecmp:                           Case insensitive comparison.
+                                                              (line  54)
+* u32_casecoll:                          Case insensitive comparison.
+                                                              (line  98)
+* u32_casefold:                          Case insensitive comparison.
+                                                              (line  18)
+* u32_casexfrm:                          Case insensitive comparison.
+                                                              (line  78)
+* u32_casing_prefix_context:             Case mappings of substrings.
+                                                              (line  32)
+* u32_casing_prefixes_context:           Case mappings of substrings.
+                                                              (line  42)
+* u32_casing_suffix_context:             Case mappings of substrings.
+                                                              (line  63)
+* u32_casing_suffixes_context:           Case mappings of substrings.
+                                                              (line  73)
+* u32_check:                             Elementary string checks.
+                                                              (line  12)
+* u32_chr:                               Elementary string functions.
+                                                              (line 147)
+* u32_cmp:                               Elementary string functions.
+                                                              (line 117)
+* u32_cmp2:                              Elementary string functions.
+                                                              (line 133)
+* u32_conv_from_encoding:                uniconv.h.           (line  57)
+* u32_conv_to_encoding:                  uniconv.h.           (line  94)
+* u32_cpy:                               Elementary string functions.
+                                                              (line  80)
+* u32_cpy_alloc:                         Elementary string functions with memory allocation.
+                                                              (line  11)
+* u32_ct_casefold:                       Case insensitive comparison.
+                                                              (line  42)
+* u32_ct_tolower:                        Case mappings of substrings.
+                                                              (line 112)
+* u32_ct_totitle:                        Case mappings of substrings.
+                                                              (line 130)
+* u32_ct_toupper:                        Case mappings of substrings.
+                                                              (line  94)
+* u32_endswith:                          Elementary string functions on NUL terminated strings.
+                                                              (line 260)
+* u32_is_cased:                          Case detection.      (line  59)
+* u32_is_casefolded:                     Case detection.      (line  46)
+* u32_is_lowercase:                      Case detection.      (line  26)
+* u32_is_titlecase:                      Case detection.      (line  36)
+* u32_is_uppercase:                      Case detection.      (line  16)
+* u32_mblen:                             Elementary string functions.
+                                                              (line  12)
+* u32_mbsnlen:                           Elementary string functions.
+                                                              (line 158)
+* u32_mbtouc:                            Elementary string functions.
+                                                              (line  39)
+* u32_mbtouc_unsafe:                     Elementary string functions.
+                                                              (line  25)
+* u32_mbtoucr:                           Elementary string functions.
+                                                              (line  46)
+* u32_move:                              Elementary string functions.
+                                                              (line  91)
+* u32_next:                              Elementary string functions on NUL terminated strings.
+                                                              (line  25)
+* u32_normalize:                         Normalization of strings.
+                                                              (line  52)
+* u32_normcmp:                           Normalizing comparisons.
+                                                              (line  15)
+* u32_normcoll:                          Normalizing comparisons.
+                                                              (line  42)
+* u32_normxfrm:                          Normalizing comparisons.
+                                                              (line  29)
+* u32_possible_linebreaks:               unilbrk.h.           (line  48)
+* u32_prev:                              Elementary string functions on NUL terminated strings.
+                                                              (line  38)
+* u32_set:                               Elementary string functions.
+                                                              (line 102)
+* u32_snprintf:                          unistdio.h.          (line 179)
+* u32_sprintf:                           unistdio.h.          (line 176)
+* u32_startswith:                        Elementary string functions on NUL terminated strings.
+                                                              (line 252)
+* u32_stpcpy:                            Elementary string functions on NUL terminated strings.
+                                                              (line  78)
+* u32_stpncpy:                           Elementary string functions on NUL terminated strings.
+                                                              (line 101)
+* u32_strcat:                            Elementary string functions on NUL terminated strings.
+                                                              (line 112)
+* u32_strchr:                            Elementary string functions on NUL terminated strings.
+                                                              (line 181)
+* u32_strcmp:                            Elementary string functions on NUL terminated strings.
+                                                              (line 133)
+* u32_strcoll:                           Elementary string functions on NUL terminated strings.
+                                                              (line 143)
+* u32_strconv_from_encoding:             uniconv.h.           (line 131)
+* u32_strconv_from_locale:               uniconv.h.           (line 158)
+* u32_strconv_to_encoding:               uniconv.h.           (line 144)
+* u32_strconv_to_locale:                 uniconv.h.           (line 168)
+* u32_strcpy:                            Elementary string functions on NUL terminated strings.
+                                                              (line  68)
+* u32_strcspn:                           Elementary string functions on NUL terminated strings.
+                                                              (line 203)
+* u32_strdup:                            Elementary string functions on NUL terminated strings.
+                                                              (line 171)
+* u32_strlen:                            Elementary string functions on NUL terminated strings.
+                                                              (line  48)
+* u32_strmblen:                          Elementary string functions on NUL terminated strings.
+                                                              (line  12)
+* u32_strmbtouc:                         Elementary string functions on NUL terminated strings.
+                                                              (line  18)
+* u32_strncat:                           Elementary string functions on NUL terminated strings.
+                                                              (line 123)
+* u32_strncmp:                           Elementary string functions on NUL terminated strings.
+                                                              (line 161)
+* u32_strncpy:                           Elementary string functions on NUL terminated strings.
+                                                              (line  90)
+* u32_strnlen:                           Elementary string functions on NUL terminated strings.
+                                                              (line  56)
+* u32_strpbrk:                           Elementary string functions on NUL terminated strings.
+                                                              (line 227)
+* u32_strrchr:                           Elementary string functions on NUL terminated strings.
+                                                              (line 189)
+* u32_strspn:                            Elementary string functions on NUL terminated strings.
+                                                              (line 215)
+* u32_strstr:                            Elementary string functions on NUL terminated strings.
+                                                              (line 241)
+* u32_strtok:                            Elementary string functions on NUL terminated strings.
+                                                              (line 270)
+* u32_strwidth:                          uniwidth.h.          (line  40)
+* u32_to_u16:                            Elementary string conversions.
+                                                              (line  31)
+* u32_to_u8:                             Elementary string conversions.
+                                                              (line  27)
+* u32_tolower:                           Case mappings of strings.
+                                                              (line  47)
+* u32_totitle:                           Case mappings of strings.
+                                                              (line  61)
+* u32_toupper:                           Case mappings of strings.
+                                                              (line  33)
+* u32_u32_asnprintf:                     unistdio.h.          (line 212)
+* u32_u32_asprintf:                      unistdio.h.          (line 209)
+* u32_u32_snprintf:                      unistdio.h.          (line 206)
+* u32_u32_sprintf:                       unistdio.h.          (line 203)
+* u32_u32_vasnprintf:                    unistdio.h.          (line 224)
+* u32_u32_vasprintf:                     unistdio.h.          (line 221)
+* u32_u32_vsnprintf:                     unistdio.h.          (line 218)
+* u32_u32_vsprintf:                      unistdio.h.          (line 215)
+* u32_uctomb:                            Elementary string functions.
+                                                              (line  63)
+* u32_vasnprintf:                        unistdio.h.          (line 197)
+* u32_vasprintf:                         unistdio.h.          (line 194)
+* u32_vsnprintf:                         unistdio.h.          (line 191)
+* u32_vsprintf:                          unistdio.h.          (line 188)
+* u32_width:                             uniwidth.h.          (line  33)
+* u32_width_linebreaks:                  unilbrk.h.           (line  68)
+* u32_wordbreaks:                        Word breaks in a string.
+                                                              (line  11)
+* u8_asnprintf:                          unistdio.h.          (line  79)
+* u8_asprintf:                           unistdio.h.          (line  76)
+* u8_casecmp:                            Case insensitive comparison.
+                                                              (line  48)
+* u8_casecoll:                           Case insensitive comparison.
+                                                              (line  92)
+* u8_casefold:                           Case insensitive comparison.
+                                                              (line  12)
+* u8_casexfrm:                           Case insensitive comparison.
+                                                              (line  72)
+* u8_casing_prefix_context:              Case mappings of substrings.
+                                                              (line  28)
+* u8_casing_prefixes_context:            Case mappings of substrings.
+                                                              (line  36)
+* u8_casing_suffix_context:              Case mappings of substrings.
+                                                              (line  59)
+* u8_casing_suffixes_context:            Case mappings of substrings.
+                                                              (line  67)
+* u8_check:                              Elementary string checks.
+                                                              (line  10)
+* u8_chr:                                Elementary string functions.
+                                                              (line 143)
+* u8_cmp:                                Elementary string functions.
+                                                              (line 113)
+* u8_cmp2:                               Elementary string functions.
+                                                              (line 129)
+* u8_conv_from_encoding:                 uniconv.h.           (line  51)
+* u8_conv_to_encoding:                   uniconv.h.           (line  88)
+* u8_cpy:                                Elementary string functions.
+                                                              (line  76)
+* u8_cpy_alloc:                          Elementary string functions with memory allocation.
+                                                              (line   9)
+* u8_ct_casefold:                        Case insensitive comparison.
+                                                              (line  32)
+* u8_ct_tolower:                         Case mappings of substrings.
+                                                              (line 102)
+* u8_ct_totitle:                         Case mappings of substrings.
+                                                              (line 120)
+* u8_ct_toupper:                         Case mappings of substrings.
+                                                              (line  84)
+* u8_endswith:                           Elementary string functions on NUL terminated strings.
+                                                              (line 256)
+* u8_is_cased:                           Case detection.      (line  55)
+* u8_is_casefolded:                      Case detection.      (line  42)
+* u8_is_lowercase:                       Case detection.      (line  22)
+* u8_is_titlecase:                       Case detection.      (line  32)
+* u8_is_uppercase:                       Case detection.      (line  12)
+* u8_mblen:                              Elementary string functions.
+                                                              (line  10)
+* u8_mbsnlen:                            Elementary string functions.
+                                                              (line 156)
+* u8_mbtouc:                             Elementary string functions.
+                                                              (line  37)
+* u8_mbtouc_unsafe:                      Elementary string functions.
+                                                              (line  21)
+* u8_mbtoucr:                            Elementary string functions.
+                                                              (line  44)
+* u8_move:                               Elementary string functions.
+                                                              (line  87)
+* u8_next:                               Elementary string functions on NUL terminated strings.
+                                                              (line  23)
+* u8_normalize:                          Normalization of strings.
+                                                              (line  48)
+* u8_normcmp:                            Normalizing comparisons.
+                                                              (line  11)
+* u8_normcoll:                           Normalizing comparisons.
+                                                              (line  38)
+* u8_normxfrm:                           Normalizing comparisons.
+                                                              (line  25)
+* u8_possible_linebreaks:                unilbrk.h.           (line  44)
+* u8_prev:                               Elementary string functions on NUL terminated strings.
+                                                              (line  34)
+* u8_set:                                Elementary string functions.
+                                                              (line 100)
+* u8_snprintf:                           unistdio.h.          (line  73)
+* u8_sprintf:                            unistdio.h.          (line  70)
+* u8_startswith:                         Elementary string functions on NUL terminated strings.
+                                                              (line 248)
+* u8_stpcpy:                             Elementary string functions on NUL terminated strings.
+                                                              (line  74)
+* u8_stpncpy:                            Elementary string functions on NUL terminated strings.
+                                                              (line  97)
+* u8_strcat:                             Elementary string functions on NUL terminated strings.
+                                                              (line 108)
+* u8_strchr:                             Elementary string functions on NUL terminated strings.
+                                                              (line 179)
+* u8_strcmp:                             Elementary string functions on NUL terminated strings.
+                                                              (line 131)
+* u8_strcoll:                            Elementary string functions on NUL terminated strings.
+                                                              (line 141)
+* u8_strconv_from_encoding:              uniconv.h.           (line 127)
+* u8_strconv_from_locale:                uniconv.h.           (line 156)
+* u8_strconv_to_encoding:                uniconv.h.           (line 140)
+* u8_strconv_to_locale:                  uniconv.h.           (line 166)
+* u8_strcpy:                             Elementary string functions on NUL terminated strings.
+                                                              (line  64)
+* u8_strcspn:                            Elementary string functions on NUL terminated strings.
+                                                              (line 199)
+* u8_strdup:                             Elementary string functions on NUL terminated strings.
+                                                              (line 169)
+* u8_strlen:                             Elementary string functions on NUL terminated strings.
+                                                              (line  46)
+* u8_strmblen:                           Elementary string functions on NUL terminated strings.
+                                                              (line  10)
+* u8_strmbtouc:                          Elementary string functions on NUL terminated strings.
+                                                              (line  16)
+* u8_strncat:                            Elementary string functions on NUL terminated strings.
+                                                              (line 119)
+* u8_strncmp:                            Elementary string functions on NUL terminated strings.
+                                                              (line 157)
+* u8_strncpy:                            Elementary string functions on NUL terminated strings.
+                                                              (line  86)
+* u8_strnlen:                            Elementary string functions on NUL terminated strings.
+                                                              (line  54)
+* u8_strpbrk:                            Elementary string functions on NUL terminated strings.
+                                                              (line 223)
+* u8_strrchr:                            Elementary string functions on NUL terminated strings.
+                                                              (line 187)
+* u8_strspn:                             Elementary string functions on NUL terminated strings.
+                                                              (line 211)
+* u8_strstr:                             Elementary string functions on NUL terminated strings.
+                                                              (line 237)
+* u8_strtok:                             Elementary string functions on NUL terminated strings.
+                                                              (line 266)
+* u8_strwidth:                           uniwidth.h.          (line  38)
+* u8_to_u16:                             Elementary string conversions.
+                                                              (line  11)
+* u8_to_u32:                             Elementary string conversions.
+                                                              (line  15)
+* u8_tolower:                            Case mappings of strings.
+                                                              (line  41)
+* u8_totitle:                            Case mappings of strings.
+                                                              (line  55)
+* u8_toupper:                            Case mappings of strings.
+                                                              (line  27)
+* u8_u8_asnprintf:                       unistdio.h.          (line 106)
+* u8_u8_asprintf:                        unistdio.h.          (line 103)
+* u8_u8_snprintf:                        unistdio.h.          (line 100)
+* u8_u8_sprintf:                         unistdio.h.          (line  97)
+* u8_u8_vasnprintf:                      unistdio.h.          (line 118)
+* u8_u8_vasprintf:                       unistdio.h.          (line 115)
+* u8_u8_vsnprintf:                       unistdio.h.          (line 112)
+* u8_u8_vsprintf:                        unistdio.h.          (line 109)
+* u8_uctomb:                             Elementary string functions.
+                                                              (line  61)
+* u8_vasnprintf:                         unistdio.h.          (line  91)
+* u8_vasprintf:                          unistdio.h.          (line  88)
+* u8_vsnprintf:                          unistdio.h.          (line  85)
+* u8_vsprintf:                           unistdio.h.          (line  82)
+* u8_width:                              uniwidth.h.          (line  29)
+* u8_width_linebreaks:                   unilbrk.h.           (line  62)
+* u8_wordbreaks:                         Word breaks in a string.
+                                                              (line   9)
+* uc_all_blocks:                         Blocks.              (line  38)
+* uc_all_scripts:                        Scripts.             (line  37)
+* uc_bidi_category:                      Bidirectional category.
+                                                              (line  88)
+* uc_bidi_category_byname:               Bidirectional category.
+                                                              (line  82)
+* uc_bidi_category_name:                 Bidirectional category.
+                                                              (line  79)
+* uc_block:                              Blocks.              (line  27)
+* uc_block_t:                            Blocks.              (line  12)
+* uc_c_ident_category:                   ISO C and Java syntax.
+                                                              (line  39)
+* uc_canonical_decomposition:            Decomposition of characters.
+                                                              (line  92)
+* uc_combining_class:                    Canonical combining class.
+                                                              (line  89)
+* uc_composition:                        Composition of characters.
+                                                              (line  10)
+* uc_decimal_value:                      Decimal digit value. (line  11)
+* uc_decomposition:                      Decomposition of characters.
+                                                              (line  82)
+* uc_digit_value:                        Digit value.         (line  11)
+* uc_fraction_t:                         Numeric value.       (line  14)
+* uc_general_category:                   Object oriented API. (line 207)
+* uc_general_category_and:               Object oriented API. (line 179)
+* uc_general_category_and_not:           Object oriented API. (line 186)
+* uc_general_category_byname:            Object oriented API. (line 201)
+* uc_general_category_name:              Object oriented API. (line 195)
+* uc_general_category_or:                Object oriented API. (line 173)
+* uc_general_category_t:                 Object oriented API. (line   7)
+* uc_is_alnum:                           Classifications like in ISO C.
+                                                              (line  14)
+* uc_is_alpha:                           Classifications like in ISO C.
+                                                              (line  18)
+* uc_is_bidi_category:                   Bidirectional category.
+                                                              (line  91)
+* uc_is_blank:                           Classifications like in ISO C.
+                                                              (line  64)
+* uc_is_block:                           Blocks.              (line  32)
+* uc_is_c_whitespace:                    ISO C and Java syntax.
+                                                              (line  10)
+* uc_is_cntrl:                           Classifications like in ISO C.
+                                                              (line  24)
+* uc_is_digit:                           Classifications like in ISO C.
+                                                              (line  27)
+* uc_is_general_category:                Object oriented API. (line 213)
+* uc_is_general_category_withtable:      Bit mask API.        (line  52)
+* uc_is_graph:                           Classifications like in ISO C.
+                                                              (line  31)
+* uc_is_java_whitespace:                 ISO C and Java syntax.
+                                                              (line  14)
+* uc_is_lower:                           Classifications like in ISO C.
+                                                              (line  35)
+* uc_is_print:                           Classifications like in ISO C.
+                                                              (line  41)
+* uc_is_property:                        Properties as objects.
+                                                              (line 140)
+* uc_is_property_alphabetic:             Properties as functions.
+                                                              (line  10)
+* uc_is_property_ascii_hex_digit:        Properties as functions.
+                                                              (line  74)
+* uc_is_property_bidi_arabic_digit:      Properties as functions.
+                                                              (line  60)
+* uc_is_property_bidi_arabic_right_to_left: Properties as functions.
+                                                              (line  56)
+* uc_is_property_bidi_block_separator:   Properties as functions.
+                                                              (line  62)
+* uc_is_property_bidi_boundary_neutral:  Properties as functions.
+                                                              (line  66)
+* uc_is_property_bidi_common_separator:  Properties as functions.
+                                                              (line  61)
+* uc_is_property_bidi_control:           Properties as functions.
+                                                              (line  53)
+* uc_is_property_bidi_embedding_or_override: Properties as functions.
+                                                              (line  68)
+* uc_is_property_bidi_eur_num_separator: Properties as functions.
+                                                              (line  58)
+* uc_is_property_bidi_eur_num_terminator: Properties as functions.
+                                                              (line  59)
+* uc_is_property_bidi_european_digit:    Properties as functions.
+                                                              (line  57)
+* uc_is_property_bidi_hebrew_right_to_left: Properties as functions.
+                                                              (line  55)
+* uc_is_property_bidi_left_to_right:     Properties as functions.
+                                                              (line  54)
+* uc_is_property_bidi_non_spacing_mark:  Properties as functions.
+                                                              (line  65)
+* uc_is_property_bidi_other_neutral:     Properties as functions.
+                                                              (line  69)
+* uc_is_property_bidi_pdf:               Properties as functions.
+                                                              (line  67)
+* uc_is_property_bidi_segment_separator: Properties as functions.
+                                                              (line  63)
+* uc_is_property_bidi_whitespace:        Properties as functions.
+                                                              (line  64)
+* uc_is_property_combining:              Properties as functions.
+                                                              (line 104)
+* uc_is_property_composite:              Properties as functions.
+                                                              (line 105)
+* uc_is_property_currency_symbol:        Properties as functions.
+                                                              (line  99)
+* uc_is_property_dash:                   Properties as functions.
+                                                              (line  91)
+* uc_is_property_decimal_digit:          Properties as functions.
+                                                              (line 106)
+* uc_is_property_default_ignorable_code_point: Properties as functions.
+                                                              (line  14)
+* uc_is_property_deprecated:             Properties as functions.
+                                                              (line  17)
+* uc_is_property_diacritic:              Properties as functions.
+                                                              (line 108)
+* uc_is_property_extender:               Properties as functions.
+                                                              (line 109)
+* uc_is_property_format_control:         Properties as functions.
+                                                              (line  90)
+* uc_is_property_grapheme_base:          Properties as functions.
+                                                              (line  46)
+* uc_is_property_grapheme_extend:        Properties as functions.
+                                                              (line  47)
+* uc_is_property_grapheme_link:          Properties as functions.
+                                                              (line  49)
+* uc_is_property_hex_digit:              Properties as functions.
+                                                              (line  73)
+* uc_is_property_hyphen:                 Properties as functions.
+                                                              (line  92)
+* uc_is_property_id_continue:            Properties as functions.
+                                                              (line  36)
+* uc_is_property_id_start:               Properties as functions.
+                                                              (line  34)
+* uc_is_property_ideographic:            Properties as functions.
+                                                              (line  78)
+* uc_is_property_ids_binary_operator:    Properties as functions.
+                                                              (line  81)
+* uc_is_property_ids_trinary_operator:   Properties as functions.
+                                                              (line  82)
+* uc_is_property_ignorable_control:      Properties as functions.
+                                                              (line 110)
+* uc_is_property_iso_control:            Properties as functions.
+                                                              (line  89)
+* uc_is_property_join_control:           Properties as functions.
+                                                              (line  45)
+* uc_is_property_left_of_pair:           Properties as functions.
+                                                              (line 103)
+* uc_is_property_line_separator:         Properties as functions.
+                                                              (line  94)
+* uc_is_property_logical_order_exception: Properties as functions.
+                                                              (line  18)
+* uc_is_property_lowercase:              Properties as functions.
+                                                              (line  27)
+* uc_is_property_math:                   Properties as functions.
+                                                              (line 100)
+* uc_is_property_non_break:              Properties as functions.
+                                                              (line  88)
+* uc_is_property_not_a_character:        Properties as functions.
+                                                              (line  12)
+* uc_is_property_numeric:                Properties as functions.
+                                                              (line 107)
+* uc_is_property_other_alphabetic:       Properties as functions.
+                                                              (line  11)
+* uc_is_property_other_default_ignorable_code_point: Properties as functions.
+                                                              (line  16)
+* uc_is_property_other_grapheme_extend:  Properties as functions.
+                                                              (line  48)
+* uc_is_property_other_id_continue:      Properties as functions.
+                                                              (line  37)
+* uc_is_property_other_id_start:         Properties as functions.
+                                                              (line  35)
+* uc_is_property_other_lowercase:        Properties as functions.
+                                                              (line  28)
+* uc_is_property_other_math:             Properties as functions.
+                                                              (line 101)
+* uc_is_property_other_uppercase:        Properties as functions.
+                                                              (line  26)
+* uc_is_property_paired_punctuation:     Properties as functions.
+                                                              (line 102)
+* uc_is_property_paragraph_separator:    Properties as functions.
+                                                              (line  95)
+* uc_is_property_pattern_syntax:         Properties as functions.
+                                                              (line  41)
+* uc_is_property_pattern_white_space:    Properties as functions.
+                                                              (line  40)
+* uc_is_property_private_use:            Properties as functions.
+                                                              (line  20)
+* uc_is_property_punctuation:            Properties as functions.
+                                                              (line  93)
+* uc_is_property_quotation_mark:         Properties as functions.
+                                                              (line  96)
+* uc_is_property_radical:                Properties as functions.
+                                                              (line  80)
+* uc_is_property_sentence_terminal:      Properties as functions.
+                                                              (line  97)
+* uc_is_property_soft_dotted:            Properties as functions.
+                                                              (line  30)
+* uc_is_property_space:                  Properties as functions.
+                                                              (line  87)
+* uc_is_property_terminal_punctuation:   Properties as functions.
+                                                              (line  98)
+* uc_is_property_titlecase:              Properties as functions.
+                                                              (line  29)
+* uc_is_property_unassigned_code_value:  Properties as functions.
+                                                              (line  21)
+* uc_is_property_unified_ideograph:      Properties as functions.
+                                                              (line  79)
+* uc_is_property_uppercase:              Properties as functions.
+                                                              (line  25)
+* uc_is_property_variation_selector:     Properties as functions.
+                                                              (line  19)
+* uc_is_property_white_space:            Properties as functions.
+                                                              (line   9)
+* uc_is_property_xid_continue:           Properties as functions.
+                                                              (line  39)
+* uc_is_property_xid_start:              Properties as functions.
+                                                              (line  38)
+* uc_is_property_zero_width:             Properties as functions.
+                                                              (line  86)
+* uc_is_punct:                           Classifications like in ISO C.
+                                                              (line  44)
+* uc_is_script:                          Scripts.             (line  31)
+* uc_is_space:                           Classifications like in ISO C.
+                                                              (line  49)
+* uc_is_upper:                           Classifications like in ISO C.
+                                                              (line  54)
+* uc_is_xdigit:                          Classifications like in ISO C.
+                                                              (line  60)
+* uc_java_ident_category:                ISO C and Java syntax.
+                                                              (line  43)
+* uc_locale_language:                    Case mappings of strings.
+                                                              (line  21)
+* uc_mirror_char:                        Mirrored character.  (line  14)
+* uc_numeric_value:                      Numeric value.       (line  23)
+* uc_property_byname:                    Properties as objects.
+                                                              (line 123)
+* uc_property_is_valid:                  Properties as objects.
+                                                              (line 133)
+* uc_property_t:                         Properties as objects.
+                                                              (line   9)
+* uc_script:                             Scripts.             (line  20)
+* uc_script_byname:                      Scripts.             (line  25)
+* uc_script_t:                           Scripts.             (line  11)
+* uc_tolower:                            Case mappings of characters.
+                                                              (line  20)
+* uc_totitle:                            Case mappings of characters.
+                                                              (line  23)
+* uc_toupper:                            Case mappings of characters.
+                                                              (line  17)
+* uc_width:                              uniwidth.h.          (line  23)
+* uc_wordbreak_property:                 Word break property. (line  32)
+* UCS-4:                                 Unicode.             (line  14)
+* ucs4_t:                                unitypes.h.          (line  16)
+* uint16_t:                              unitypes.h.          (line  10)
+* uint32_t:                              unitypes.h.          (line  11)
+* uint8_t:                               unitypes.h.          (line   9)
+* ulc_asnprintf:                         unistdio.h.          (line  53)
+* ulc_asprintf:                          unistdio.h.          (line  50)
+* ulc_casecmp:                           Case insensitive comparison.
+                                                              (line  57)
+* ulc_casecoll:                          Case insensitive comparison.
+                                                              (line 101)
+* ulc_casexfrm:                          Case insensitive comparison.
+                                                              (line  81)
+* ulc_fprintf:                           unistdio.h.          (line 229)
+* ulc_possible_linebreaks:               unilbrk.h.           (line  50)
+* ulc_snprintf:                          unistdio.h.          (line  48)
+* ulc_sprintf:                           unistdio.h.          (line  45)
+* ulc_vasnprintf:                        unistdio.h.          (line  65)
+* ulc_vasprintf:                         unistdio.h.          (line  62)
+* ulc_vfprintf:                          unistdio.h.          (line 232)
+* ulc_vsnprintf:                         unistdio.h.          (line  59)
+* ulc_vsprintf:                          unistdio.h.          (line  56)
+* ulc_width_linebreaks:                  unilbrk.h.           (line  71)
+* ulc_wordbreaks:                        Word breaks in a string.
+                                                              (line  12)
+* Unicode:                               Unicode.             (line   6)
+* Unicode character, bidirectional category: Bidirectional category.
+                                                              (line   6)
+* Unicode character, block:              Blocks.              (line  24)
+* Unicode character, canonical combining class: Canonical combining class.
+                                                              (line   6)
+* Unicode character, case mappings:      Case mappings of characters.
+                                                              (line   6)
+* Unicode character, classification:     General category.    (line   6)
+* Unicode character, classification like in C: Classifications like in ISO C.
+                                                              (line   6)
+* Unicode character, general category:   General category.    (line   6)
+* Unicode character, mirroring:          Mirrored character.  (line   6)
+* Unicode character, name:               uniname.h.           (line   6)
+* Unicode character, properties:         Properties.          (line   6)
+* Unicode character, script:             Scripts.             (line  17)
+* Unicode character, validity in C identifiers: ISO C and Java syntax.
+                                                              (line  38)
+* Unicode character, validity in Java identifiers: ISO C and Java syntax.
+                                                              (line  42)
+* Unicode character, value <1>:          Numeric value.       (line   6)
+* Unicode character, value <2>:          Digit value.         (line   6)
+* Unicode character, value:              Decimal digit value. (line   6)
+* Unicode character, width:              uniwidth.h.          (line  22)
+* unicode_character_name:                uniname.h.           (line  19)
+* unicode_name_character:                uniname.h.           (line  25)
+* uninorm_decomposing_form:              Normalization of strings.
+                                                              (line  40)
+* uninorm_filter_create:                 Normalization of streams.
+                                                              (line  19)
+* uninorm_filter_flush:                  Normalization of streams.
+                                                              (line  33)
+* uninorm_filter_free:                   Normalization of streams.
+                                                              (line  43)
+* uninorm_filter_write:                  Normalization of streams.
+                                                              (line  29)
+* uninorm_is_compat_decomposing:         Normalization of strings.
+                                                              (line  32)
+* uninorm_is_composing:                  Normalization of strings.
+                                                              (line  36)
+* uninorm_t:                             Normalization of strings.
+                                                              (line  10)
+* uppercasing:                           Case mappings of strings.
+                                                              (line   6)
+* use cases:                             Introduction.        (line  44)
+* UTF-16:                                Unicode.             (line  14)
+* UTF-16, strings:                       Unicode strings.     (line   6)
+* UTF-32:                                Unicode.             (line  14)
+* UTF-32, strings:                       Unicode strings.     (line   6)
+* UTF-8:                                 Unicode.             (line  14)
+* UTF-8, strings:                        Unicode strings.     (line   6)
+* validity:                              Elementary string checks.
+                                                              (line   6)
+* value, of libunistring:                Introduction.        (line  44)
+* value, of Unicode character <1>:       Numeric value.       (line   6)
+* value, of Unicode character <2>:       Digit value.         (line   6)
+* value, of Unicode character:           Decimal digit value. (line   6)
+* verification:                          Elementary string checks.
+                                                              (line   6)
+* wchar_t, type:                         The wchar_t mess.    (line   6)
+* width:                                 uniwidth.h.          (line   6)
+* word breaks:                           uniwbrk.h.           (line   6)
+* wrapping:                              unilbrk.h.           (line   6)
+
+
+
+Tag Table:
+Node: Top270
+Node: Introduction3239
+Node: Unicode5236
+Node: Unicode and i18n7116
+Node: Locale encodings8579
+Node: In-memory representation10787
+Node: char * strings11896
+Node: The wchar_t mess17153
+Node: Unicode strings19357
+Node: Conventions20508
+Node: unitypes.h22708
+Node: unistr.h23280
+Node: Elementary string checks23837
+Node: Elementary string conversions24459
+Node: Elementary string functions25761
+Node: Elementary string functions with memory allocation32732
+Node: Elementary string functions on NUL terminated strings33354
+Node: uniconv.h45090
+Node: unistdio.h52801
+Node: uniname.h61004
+Node: unictype.h62337
+Node: General category63246
+Node: Object oriented API64289
+Node: Bit mask API72751
+Node: Canonical combining class75005
+Node: Bidirectional category78219
+Node: Decimal digit value81276
+Node: Digit value81837
+Node: Numeric value82398
+Node: Mirrored character83289
+Node: Properties83962
+Node: Properties as objects84653
+Node: Properties as functions91031
+Node: Scripts96582
+Node: Blocks97968
+Node: ISO C and Java syntax99291
+Node: Classifications like in ISO C101001
+Node: uniwidth.h103705
+Node: uniwbrk.h105742
+Node: Word breaks in a string106269
+Node: Word break property107320
+Node: unilbrk.h108416
+Node: uninorm.h112587
+Node: Decomposition of characters113219
+Node: Composition of characters116595
+Node: Normalization of strings117304
+Node: Normalizing comparisons119366
+Node: Normalization of streams121722
+Node: unicase.h123810
+Node: Case mappings of characters124495
+Node: Case mappings of strings126542
+Node: Case mappings of substrings129875
+Node: Case insensitive comparison136805
+Node: Case detection142156
+Node: uniregex.h145424
+Node: Using the library145647
+Node: Installation146058
+Node: Compiler options146531
+Node: Include files148090
+Node: Autoconf macro149314
+Node: Reporting problems150872
+Node: More functionality151669
+Node: Licenses152112
+Node: GNU GPL153747
+Node: GNU LGPL191292
+Node: GNU FDL199738
+Node: Index224863
+
+End Tag Table
+
+
+Local Variables:
+coding: utf-8
+End: