Unicode Manipulation

Unicode Manipulation — функции оперирующие на Unicode символах и UTF-8 строках.

Краткое описание



#include <glib.h>


typedef     gunichar;
typedef     gunichar2;

gboolean    g_unichar_validate              (gunichar ch);
gboolean    g_unichar_isalnum               (gunichar c);
gboolean    g_unichar_isalpha               (gunichar c);
gboolean    g_unichar_iscntrl               (gunichar c);
gboolean    g_unichar_isdigit               (gunichar c);
gboolean    g_unichar_isgraph               (gunichar c);
gboolean    g_unichar_islower               (gunichar c);
gboolean    g_unichar_isprint               (gunichar c);
gboolean    g_unichar_ispunct               (gunichar c);
gboolean    g_unichar_isspace               (gunichar c);
gboolean    g_unichar_isupper               (gunichar c);
gboolean    g_unichar_isxdigit              (gunichar c);
gboolean    g_unichar_istitle               (gunichar c);
gboolean    g_unichar_isdefined             (gunichar c);
gboolean    g_unichar_iswide                (gunichar c);
gboolean    g_unichar_iswide_cjk            (gunichar c);
gunichar    g_unichar_toupper               (gunichar c);
gunichar    g_unichar_tolower               (gunichar c);
gunichar    g_unichar_totitle               (gunichar c);
gint        g_unichar_digit_value           (gunichar c);
gint        g_unichar_xdigit_value          (gunichar c);
enum        GUnicodeType;
GUnicodeType g_unichar_type                 (gunichar c);
enum        GUnicodeBreakType;
GUnicodeBreakType g_unichar_break_type      (gunichar c);
void        g_unicode_canonical_ordering    (gunichar *string,
                                             gsize len);
gunichar*   g_unicode_canonical_decomposition
                                            (gunichar ch,
                                             gsize *result_len);
gboolean    g_unichar_get_mirror_char       (gunichar ch,
                                             gunichar *mirrored_ch);
enum        GUnicodeScript;
GUnicodeScript g_unichar_get_script         (gunichar ch);

#define     g_utf8_next_char                (p)
gunichar    g_utf8_get_char                 (const gchar *p);
gunichar    g_utf8_get_char_validated       (const gchar *p,
                                             gssize max_len);
gchar*      g_utf8_offset_to_pointer        (const gchar *str,
                                             glong offset);
glong       g_utf8_pointer_to_offset        (const gchar *str,
                                             const gchar *pos);
gchar*      g_utf8_prev_char                (const gchar *p);
gchar*      g_utf8_find_next_char           (const gchar *p,
                                             const gchar *end);
gchar*      g_utf8_find_prev_char           (const gchar *str,
                                             const gchar *p);
glong       g_utf8_strlen                   (const gchar *p,
                                             gssize max);
gchar*      g_utf8_strncpy                  (gchar *dest,
                                             const gchar *src,
                                             gsize n);
gchar*      g_utf8_strchr                   (const gchar *p,
                                             gssize len,
                                             gunichar c);
gchar*      g_utf8_strrchr                  (const gchar *p,
                                             gssize len,
                                             gunichar c);
gchar*      g_utf8_strreverse               (const gchar *str,
                                             gssize len);
gboolean    g_utf8_validate                 (const gchar *str,
                                             gssize max_len,
                                             const gchar **end);

gchar*      g_utf8_strup                    (const gchar *str,
                                             gssize len);
gchar*      g_utf8_strdown                  (const gchar *str,
                                             gssize len);
gchar*      g_utf8_casefold                 (const gchar *str,
                                             gssize len);
gchar*      g_utf8_normalize                (const gchar *str,
                                             gssize len,
                                             GNormalizeMode mode);
enum        GNormalizeMode;
gint        g_utf8_collate                  (const gchar *str1,
                                             const gchar *str2);
gchar*      g_utf8_collate_key              (const gchar *str,
                                             gssize len);
gchar*      g_utf8_collate_key_for_filename (const gchar *str,
                                             gssize len);

gunichar2*  g_utf8_to_utf16                 (const gchar *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);
gunichar*   g_utf8_to_ucs4                  (const gchar *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);
gunichar*   g_utf8_to_ucs4_fast             (const gchar *str,
                                             glong len,
                                             glong *items_written);
gunichar*   g_utf16_to_ucs4                 (const gunichar2 *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);
gchar*      g_utf16_to_utf8                 (const gunichar2 *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);
gunichar2*  g_ucs4_to_utf16                 (const gunichar *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);
gchar*      g_ucs4_to_utf8                  (const gunichar *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);
gint        g_unichar_to_utf8               (gunichar c,
                                             gchar *outbuf);

Описание

Эта секция описывает множество функций для работы с Unicode символами и строками. Они аналогичны традиционной классификации символа ctype.h и функциям приведения и преобразования, UTF-8 аналогичны таким же строковым функциям, функции выполнения нормализации, преобразование регистра и сопоставление в UTF-8 строках и наконец функции для преобразования между UTF-8, UTF-16 и UCS-4 кодировками Unicode.

Реализация Unicode функций в GLib базируется на таблице данных символов Unicode (Unicode Character Data tables), которая доступна из www.unicode.org. GLib 2.8 поддерживает Unicode 4.0, GLib 2.10 поддерживает Unicode 4.1, GLib 2.12 поддерживает Unicode 5.0.

Детали

gunichar

typedef guint32 gunichar;

Тип который может содержать любой код символа UCS-4.

gunichar2

typedef guint16 gunichar2;

Тип который может содержать любой указатель кода UTF-16^[3].

g_unichar_validate ()

gboolean g_unichar_validate (gunichar ch);

Проверяет является ли ch допустимым символом Unicode. Любые возможные целочисленные значения ch не будут допустимы. 0 рассматривается как правильный символ, хотя обычно он является концом строки.

`ch` :	Unicode символ
Возвращает :	`TRUE` если `ch` является допустимым Unicode символом.

g_unichar_isalnum ()

gboolean g_unichar_isalnum (gunichar c);

Определяет является ли символ алфавитно-цифровым. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

`c` :	Unicode символ
Возвращает :	`TRUE` если `c` является алфавитно-цифровым символом

g_unichar_isalpha ()

gboolean g_unichar_isalpha (gunichar c);

Определяет является ли символ алфавитным (то есть буквой). Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

`c` :	Unicode символ
Возвращает :	`TRUE` если `c` является алфавитным символом

g_unichar_iscntrl ()

gboolean g_unichar_iscntrl (gunichar c);

Определяет является ли символ управляющим символом. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

`c` :	Unicode символ
Возвращает :	`TRUE` если `c` является управляющим символом

g_unichar_isdigit ()

gboolean g_unichar_isdigit (gunichar c);

Определяет является ли символ числовым (то есть цифрой). Это распространяется на ASCII 0-9 а так же цифры в других языках/сценариях. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

`c` :	Unicode символ
Возвращает :	`TRUE` если `c` является цифрой

g_unichar_isgraph ()

gboolean g_unichar_isgraph (gunichar c);

Определяет является ли символ печатным и не пробелом (возвращает FALSE для управляющих символов, символов форматирования, и пробелов). Похожа на g_unichar_isprint(), но возвращает TRUE для пробелов. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

`c` :	Unicode символ
Возвращает :	`TRUE` если `c` является печатным символом отличающимся от пробела

g_unichar_islower ()

gboolean g_unichar_islower (gunichar c);

Определяет является ли символ буквой в нижнем регистре. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

`c` :	Unicode символ
Возвращает :	`TRUE` если `c` является буквой нижнего регистра

g_unichar_isprint ()

gboolean g_unichar_isprint (gunichar c);

Определяет является ли символ печатным. В отличие от g_unichar_isgraph(), возвращает TRUE для пробелов. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

`c` :	Unicode символ
Возвращает :	`TRUE` если `c` является печатным

g_unichar_ispunct ()

gboolean g_unichar_ispunct (gunichar c);

Определяет является ли символ символом пунктуации или знаком. Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

`c` :	Unicode символ
Возвращает :	`TRUE` если `c` является символом пунктуации или знаком

g_unichar_isspace ()

gboolean g_unichar_isspace (gunichar c);

Определяет является ли символ пробелом, табуляцией, или строковым разделителем (перевод строки, возврат каретки, и т.д.). Получая некоторый UTF-8 текст, определяет значение символа с помощью g_utf8_get_char().

(Помните: не нужно использовать это для прерывания слова; вы должны использовать Pango или эквивалент для получения правильного прерывания слова, алгоритм довольно сложен.)

`c` :	Unicode символ
Возвращает :	`TRUE` если `c` является символом пробела

g_unichar_isupper ()

gboolean g_unichar_isupper (gunichar c);

Определяет является ли символ символом верхнего регистра.

`c` :	Unicode символ
Возвращает :	`TRUE` если `c` является символом верхнего регистра

g_unichar_isxdigit ()

gboolean g_unichar_isxdigit (gunichar c);

Определяет является ли символ шестнадцатеричным числом.

`c` :	Unicode символ.
Возвращает :	`TRUE` если символ является шестнадцатеричным числом

g_unichar_istitle ()

gboolean g_unichar_istitle (gunichar c);

Определяет является ли символ символом заголовочного регистра (titlecase). Некоторые символы в Unicode которые являются составными, такие как DZ диаграф имеют три варианта регистра вместо двух. Форма заголовочного регистра (titlecase) используется в начале слова, где только первый символ напечатан только прописными буквами. Форма заголовочного регистра (titlecase) из DZ диаграфа это U+01F2 ЛАТИНСКАЯ ПРОПИСНАЯ БУКВА D СО СТРОЧНОЙ БУКВОЙ Z.

`c` :	Unicode символ
Возвращает :	`TRUE` если символ в заголовочном регистре (titlecase)

g_unichar_isdefined ()

gboolean g_unichar_isdefined (gunichar c);

Определяет является ли полученный символ назначенным в Unicode стандарте.

`c` :	Unicode символ
Возвращает :	`TRUE` если символ имеет назначенное значение

g_unichar_iswide ()

gboolean g_unichar_iswide (gunichar c);

Определяет если символ обычно отрисовывается в ячейке двойной ширины.

`c` :	Unicode символ
Возвращает :	`TRUE` если символ широкий

g_unichar_iswide_cjk ()

gboolean g_unichar_iswide_cjk (gunichar c);

Определяет если символ обычно отрисовывается в ячейке двойной ширины устаревшей East Asian локали. Если символ шире согласно g_unichar_iswide(), то он также сообщает ширину этой функции, но обратное не обязательно верно. Смотрите Unicode Standard Annex 11 для детального изучения.

`c` :	Unicode символ
Возвращает :	`TRUE` если символ шириной устаревшей East Asian локали

Начиная с версии 2.12

g_unichar_toupper ()

gunichar g_unichar_toupper (gunichar c);

Конвертирует символ в верхний регистр.

`c` :	Unicode символ
Возвращает :	результат конвертации `c` в верхний регистр. Если `c` не является символом нижнего регистра или заголовочного регистра (titlecase), или не имеет эквивалента в верхнем регистре, `c` возвращается без изменений.

g_unichar_tolower ()

gunichar g_unichar_tolower (gunichar c);

Конвертирует символ в нижний регистр.

`c` :	Unicode символ.
Возвращает :	результат конвертации `c` в нижний регистр. Если `c` не является символом верхнего регистра или заголовочного регистра (titlecase), или не имеет эквивалента в нижнем регистре, то `c` возвращается без изменений.

g_unichar_totitle ()

gunichar g_unichar_totitle (gunichar c);

Конвертирует символ в заголовочный регистр.

`c` :	Unicode символ
Возвращает :	результат конвертации `c` в заголовочный регистр. Если `c` не является символом верхнего регистра или символом нижнего регистра, то `c` возвращается без изменений.

g_unichar_digit_value ()

gint g_unichar_digit_value (gunichar c);

Определяет числовое значение символа как десятичное число.

`c` :	Unicode символ
Возвращает :	Если `c` десятичное число (согласно `g_unichar_isdigit()`), его числовое значение. Иначе, -1.

g_unichar_xdigit_value ()

gint g_unichar_xdigit_value (gunichar c);

Определяет числовое значение символа как шестнадцатеричное число.

`c` :	Unicode символ
Возвращает :	Если `c` это шестнадцатеричное число (согласно `g_unichar_isxdigit()`), его цифровое значение. Иначе, -1.

enum GUnicodeType

typedef enum
{
  G_UNICODE_CONTROL,
  G_UNICODE_FORMAT,
  G_UNICODE_UNASSIGNED,
  G_UNICODE_PRIVATE_USE,
  G_UNICODE_SURROGATE,
  G_UNICODE_LOWERCASE_LETTER,
  G_UNICODE_MODIFIER_LETTER,
  G_UNICODE_OTHER_LETTER,
  G_UNICODE_TITLECASE_LETTER,
  G_UNICODE_UPPERCASE_LETTER,
  G_UNICODE_COMBINING_MARK,
  G_UNICODE_ENCLOSING_MARK,
  G_UNICODE_NON_SPACING_MARK,
  G_UNICODE_DECIMAL_NUMBER,
  G_UNICODE_LETTER_NUMBER,
  G_UNICODE_OTHER_NUMBER,
  G_UNICODE_CONNECT_PUNCTUATION,
  G_UNICODE_DASH_PUNCTUATION,
  G_UNICODE_CLOSE_PUNCTUATION,
  G_UNICODE_FINAL_PUNCTUATION,
  G_UNICODE_INITIAL_PUNCTUATION,
  G_UNICODE_OTHER_PUNCTUATION,
  G_UNICODE_OPEN_PUNCTUATION,
  G_UNICODE_CURRENCY_SYMBOL,
  G_UNICODE_MODIFIER_SYMBOL,
  G_UNICODE_MATH_SYMBOL,
  G_UNICODE_OTHER_SYMBOL,
  G_UNICODE_LINE_SEPARATOR,
  G_UNICODE_PARAGRAPH_SEPARATOR,
  G_UNICODE_SPACE_SEPARATOR
} GUnicodeType;

Это возможная классификация символа из спецификации Unicode. Смотрите http://www.unicode.org/Public/UNIDATA/UnicodeData.html.

`G_UNICODE_CONTROL`	Основная категория "Other, Control" (Cc)
`G_UNICODE_FORMAT`	Основная категория "Other, Format" (Cf)
`G_UNICODE_UNASSIGNED`	Основная категория "Other, Not Assigned" (Cn)
`G_UNICODE_PRIVATE_USE`	Основная категория "Other, Private Use" (Co)
`G_UNICODE_SURROGATE`	Основная категория "Other, Surrogate" (Cs)
`G_UNICODE_LOWERCASE_LETTER`	Основная категория "Letter, Lowercase" (Ll)
`G_UNICODE_MODIFIER_LETTER`	Основная категория "Letter, Modifier" (Lm)
`G_UNICODE_OTHER_LETTER`	Основная категория "Letter, Other" (Lo)
`G_UNICODE_TITLECASE_LETTER`	Основная категория "Letter, Titlecase" (Lt)
`G_UNICODE_UPPERCASE_LETTER`	Основная категория "Letter, Uppercase" (Lu)
`G_UNICODE_COMBINING_MARK`	Основная категория "Mark, Spacing Combining" (Mc)
`G_UNICODE_ENCLOSING_MARK`	Основная категория "Mark, Enclosing" (Me)
`G_UNICODE_NON_SPACING_MARK`	Основная категория "Mark, Nonspacing" (Mn)
`G_UNICODE_DECIMAL_NUMBER`	Основная категория "Number, Decimal Digit" (Nd)
`G_UNICODE_LETTER_NUMBER`	Основная категория "Number, Letter" (Nl)
`G_UNICODE_OTHER_NUMBER`	Основная категория "Number, Other" (No)
`G_UNICODE_CONNECT_PUNCTUATION`	Основная категория "Punctuation, Connector" (Pc)
`G_UNICODE_DASH_PUNCTUATION`	Основная категория "Punctuation, Dash" (Pd)
`G_UNICODE_CLOSE_PUNCTUATION`	Основная категория "Punctuation, Close" (Pe)
`G_UNICODE_FINAL_PUNCTUATION`	Основная категория "Punctuation, Final quote" (Pf)
`G_UNICODE_INITIAL_PUNCTUATION`	Основная категория "Punctuation, Initial quote" (Pi)
`G_UNICODE_OTHER_PUNCTUATION`	Основная категория "Punctuation, Other" (Po)
`G_UNICODE_OPEN_PUNCTUATION`	Основная категория "Punctuation, Open" (Ps)
`G_UNICODE_CURRENCY_SYMBOL`	Основная категория "Symbol, Currency" (Sc)
`G_UNICODE_MODIFIER_SYMBOL`	Основная категория "Symbol, Modifier" (Sk)
`G_UNICODE_MATH_SYMBOL`	Основная категория "Symbol, Math" (Sm)
`G_UNICODE_OTHER_SYMBOL`	Основная категория "Symbol, Other" (So)
`G_UNICODE_LINE_SEPARATOR`	Основная категория "Separator, Line" (Zl)
`G_UNICODE_PARAGRAPH_SEPARATOR`	Основная категория "Separator, Paragraph" (Zp)
`G_UNICODE_SPACE_SEPARATOR`	Основная категория "Separator, Space" (Zs)

g_unichar_type ()

GUnicodeType g_unichar_type (gunichar c);

Класифицирует Unicode символ по типу.

`c` :	Unicode символ
Возвращает :	тип символа.

enum GUnicodeBreakType

typedef enum
{
  G_UNICODE_BREAK_MANDATORY,
  G_UNICODE_BREAK_CARRIAGE_RETURN,
  G_UNICODE_BREAK_LINE_FEED,
  G_UNICODE_BREAK_COMBINING_MARK,
  G_UNICODE_BREAK_SURROGATE,
  G_UNICODE_BREAK_ZERO_WIDTH_SPACE,
  G_UNICODE_BREAK_INSEPARABLE,
  G_UNICODE_BREAK_NON_BREAKING_GLUE,
  G_UNICODE_BREAK_CONTINGENT,
  G_UNICODE_BREAK_SPACE,
  G_UNICODE_BREAK_AFTER,
  G_UNICODE_BREAK_BEFORE,
  G_UNICODE_BREAK_BEFORE_AND_AFTER,
  G_UNICODE_BREAK_HYPHEN,
  G_UNICODE_BREAK_NON_STARTER,
  G_UNICODE_BREAK_OPEN_PUNCTUATION,
  G_UNICODE_BREAK_CLOSE_PUNCTUATION,
  G_UNICODE_BREAK_QUOTATION,
  G_UNICODE_BREAK_EXCLAMATION,
  G_UNICODE_BREAK_IDEOGRAPHIC,
  G_UNICODE_BREAK_NUMERIC,
  G_UNICODE_BREAK_INFIX_SEPARATOR,
  G_UNICODE_BREAK_SYMBOL,
  G_UNICODE_BREAK_ALPHABETIC,
  G_UNICODE_BREAK_PREFIX,
  G_UNICODE_BREAK_POSTFIX,
  G_UNICODE_BREAK_COMPLEX_CONTEXT,
  G_UNICODE_BREAK_AMBIGUOUS,
  G_UNICODE_BREAK_UNKNOWN,
  G_UNICODE_BREAK_NEXT_LINE,
  G_UNICODE_BREAK_WORD_JOINER,
  G_UNICODE_BREAK_HANGUL_L_JAMO,
  G_UNICODE_BREAK_HANGUL_V_JAMO,
  G_UNICODE_BREAK_HANGUL_T_JAMO,
  G_UNICODE_BREAK_HANGUL_LV_SYLLABLE,
  G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE
} GUnicodeBreakType;

Это классификация возможных прерываний строк. Пять типов корейской азбуки (Hangul) добавлены в Unicode 4.1, поэтому были введены в GLib 2.10. Помните что новые типы могут быть добавлены в будущем. Приложения должны быть готовы обрабатывать не известные значения. Они могут расцениваться как G_UNICODE_BREAK_UNKNOWN. Смотрите http://www.unicode.org/unicode/reports/tr14/.

g_unichar_break_type ()

GUnicodeBreakType g_unichar_break_type (gunichar c);

Определяет тип прерывания c. c должен быть Unicode символом (для извлечения символа из текста в кодировке UTF-8, используйте g_utf8_get_char()). Тип прерывания используется для поиска конца слова и строки ("границы текста"), Pango реализует алгоритмы разрешения границ Unicode и обычно вы должны использовать функции такие как pango_break() вместо того, чтобы беспокоится о типе границы самостоятельно.

`c` :	Unicode символ
Возвращает :	тип границы `c`

g_unicode_canonical_ordering ()

void        g_unicode_canonical_ordering    (gunichar *string,
                                             gsize len);

Расчитывает канонический порядок строки на месте. Это перераспределяет разложение символов в строке согласно их классам объединения. Смотрите руководство Unicode для большей информации.

`string` :	строка в кодировке UCS-4.
`len` :	максимальная длина строки `string` для использования.

g_unicode_canonical_decomposition ()

gunichar*   g_unicode_canonical_decomposition
                                            (gunichar ch,
                                             gsize *result_len);

Расчитывает каноническую декомпозицию символа Unicode.

`ch` :	Unicode символ.
`result_len` :	расположение для хранения длины возвращаемого значения.
Возвращает :	вновь распределённая строка Unicode символов. `result_len` устанавливается в результирующую длину строки.

g_unichar_get_mirror_char ()

gboolean    g_unichar_get_mirror_char       (gunichar ch,
                                             gunichar *mirrored_ch);

В Unicode, некоторые символы являются зеркальными (mirrored). Это значит что их изображение является отражённым горизонтально в тексте который расположен с право на лево. Например, "(" стал бы зеркальным отражением, ")", в тексте с обратной ориентацией (right-to-left).

Если ch имеет зеркальное свойство Unicode и есть другой символ unicode который обычно имеет глиф являющийся зеркальным изображением ch's глифа и параметр mirrored_ch установлен, он помещает символ в адрес указанный mirrored_ch. Иначе размещается оригинальный символ.

`ch` :	Unicode символ
`mirrored_ch` :	расположение для хранения отражённого символа
Возвращает :	`TRUE` если `ch` имеет зеркальный символ, иначе `FALSE`

Начиная с версии 2.4

enum GUnicodeScript

typedef enum 
{                         /* ISO 15924 code */
  G_UNICODE_SCRIPT_INVALID_CODE = -1,
  G_UNICODE_SCRIPT_COMMON       = 0,   /* Zyyy */
  G_UNICODE_SCRIPT_INHERITED,          /* Qaai */
  G_UNICODE_SCRIPT_ARABIC,             /* Arab */
  G_UNICODE_SCRIPT_ARMENIAN,           /* Armn */
  G_UNICODE_SCRIPT_BENGALI,            /* Beng */
  G_UNICODE_SCRIPT_BOPOMOFO,           /* Bopo */
  G_UNICODE_SCRIPT_CHEROKEE,           /* Cher */
  G_UNICODE_SCRIPT_COPTIC,             /* Qaac */
  G_UNICODE_SCRIPT_CYRILLIC,           /* Cyrl (Cyrs) */
  G_UNICODE_SCRIPT_DESERET,            /* Dsrt */
  G_UNICODE_SCRIPT_DEVANAGARI,         /* Deva */
  G_UNICODE_SCRIPT_ETHIOPIC,           /* Ethi */
  G_UNICODE_SCRIPT_GEORGIAN,           /* Geor (Geon, Geoa) */
  G_UNICODE_SCRIPT_GOTHIC,             /* Goth */
  G_UNICODE_SCRIPT_GREEK,              /* Grek */
  G_UNICODE_SCRIPT_GUJARATI,           /* Gujr */
  G_UNICODE_SCRIPT_GURMUKHI,           /* Guru */
  G_UNICODE_SCRIPT_HAN,                /* Hani */
  G_UNICODE_SCRIPT_HANGUL,             /* Hang */
  G_UNICODE_SCRIPT_HEBREW,             /* Hebr */
  G_UNICODE_SCRIPT_HIRAGANA,           /* Hira */
  G_UNICODE_SCRIPT_KANNADA,            /* Knda */
  G_UNICODE_SCRIPT_KATAKANA,           /* Kana */
  G_UNICODE_SCRIPT_KHMER,              /* Khmr */
  G_UNICODE_SCRIPT_LAO,                /* Laoo */
  G_UNICODE_SCRIPT_LATIN,              /* Latn (Latf, Latg) */
  G_UNICODE_SCRIPT_MALAYALAM,          /* Mlym */
  G_UNICODE_SCRIPT_MONGOLIAN,          /* Mong */
  G_UNICODE_SCRIPT_MYANMAR,            /* Mymr */
  G_UNICODE_SCRIPT_OGHAM,              /* Ogam */
  G_UNICODE_SCRIPT_OLD_ITALIC,         /* Ital */
  G_UNICODE_SCRIPT_ORIYA,              /* Orya */
  G_UNICODE_SCRIPT_RUNIC,              /* Runr */
  G_UNICODE_SCRIPT_SINHALA,            /* Sinh */
  G_UNICODE_SCRIPT_SYRIAC,             /* Syrc (Syrj, Syrn, Syre) */
  G_UNICODE_SCRIPT_TAMIL,              /* Taml */
  G_UNICODE_SCRIPT_TELUGU,             /* Telu */
  G_UNICODE_SCRIPT_THAANA,             /* Thaa */
  G_UNICODE_SCRIPT_THAI,               /* Thai */
  G_UNICODE_SCRIPT_TIBETAN,            /* Tibt */
  G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, /* Cans */
  G_UNICODE_SCRIPT_YI,                 /* Yiii */
  G_UNICODE_SCRIPT_TAGALOG,            /* Tglg */
  G_UNICODE_SCRIPT_HANUNOO,            /* Hano */
  G_UNICODE_SCRIPT_BUHID,              /* Buhd */
  G_UNICODE_SCRIPT_TAGBANWA,           /* Tagb */

  /* Unicode-4.0 additions */
  G_UNICODE_SCRIPT_BRAILLE,            /* Brai */
  G_UNICODE_SCRIPT_CYPRIOT,            /* Cprt */
  G_UNICODE_SCRIPT_LIMBU,              /* Limb */
  G_UNICODE_SCRIPT_OSMANYA,            /* Osma */
  G_UNICODE_SCRIPT_SHAVIAN,            /* Shaw */
  G_UNICODE_SCRIPT_LINEAR_B,           /* Linb */
  G_UNICODE_SCRIPT_TAI_LE,             /* Tale */
  G_UNICODE_SCRIPT_UGARITIC,           /* Ugar */
      
  /* Unicode-4.1 additions */
  G_UNICODE_SCRIPT_NEW_TAI_LUE,        /* Talu */
  G_UNICODE_SCRIPT_BUGINESE,           /* Bugi */
  G_UNICODE_SCRIPT_GLAGOLITIC,         /* Glag */
  G_UNICODE_SCRIPT_TIFINAGH,           /* Tfng */
  G_UNICODE_SCRIPT_SYLOTI_NAGRI,       /* Sylo */
  G_UNICODE_SCRIPT_OLD_PERSIAN,        /* Xpeo */
  G_UNICODE_SCRIPT_KHAROSHTHI,         /* Khar */

  /* Unicode-5.0 additions */
  G_UNICODE_SCRIPT_UNKNOWN,            /* Zzzz */
  G_UNICODE_SCRIPT_BALINESE,           /* Bali */
  G_UNICODE_SCRIPT_CUNEIFORM,          /* Xsux */
  G_UNICODE_SCRIPT_PHOENICIAN,         /* Phnx */
  G_UNICODE_SCRIPT_PHAGS_PA,           /* Phag */
  G_UNICODE_SCRIPT_NKO                 /* Nkoo */
} GUnicodeScript;

Перечисление GUnicodeScript идентифицирует различные системы записи. Значения соответствуют именам определённым в стандарте Unicode. Перечисление было добавлено в GLib 2.14. Помните что новые типы могут быть добавлены в будущем. Приложения должны уметь обрабатывать неизвестные значения. Смотрите Unicode Standard Annex 24: Script names.

`G_UNICODE_SCRIPT_INVALID_CODE`	значение никогда не возвращаемое из `g_unichar_get_script()`
`G_UNICODE_SCRIPT_COMMON`	символ используемый в множестве различных писменностях
`G_UNICODE_SCRIPT_INHERITED`	маркер глифа который берёт его письменность из основного глифа к которому он прикреплён
`G_UNICODE_SCRIPT_ARABIC`	Арабский язык
`G_UNICODE_SCRIPT_ARMENIAN`	Армянский язык
`G_UNICODE_SCRIPT_BENGALI`	Бенгальский язык
`G_UNICODE_SCRIPT_BOPOMOFO`	Китайский (Bopomofo)
`G_UNICODE_SCRIPT_CHEROKEE`	Cherokee
`G_UNICODE_SCRIPT_COPTIC`	Коптский язык (Coptic)
`G_UNICODE_SCRIPT_CYRILLIC`	Кириллица (Cyrillic)
`G_UNICODE_SCRIPT_DESERET`	Deseret
`G_UNICODE_SCRIPT_DEVANAGARI`	Деванагари (Devanagari)
`G_UNICODE_SCRIPT_ETHIOPIC`	Древнеэфиопский (Ethiopic)
`G_UNICODE_SCRIPT_GEORGIAN`	Грузинский (Georgian)
`G_UNICODE_SCRIPT_GOTHIC`	Готический (Gothic)
`G_UNICODE_SCRIPT_GREEK`	Греческий (Greek)
`G_UNICODE_SCRIPT_GUJARATI`	Gujarati
`G_UNICODE_SCRIPT_GURMUKHI`	Gurmukhi
`G_UNICODE_SCRIPT_HAN`	Ханьшуй (Han)
`G_UNICODE_SCRIPT_HANGUL`	Хангул (Hangul)
`G_UNICODE_SCRIPT_HEBREW`	Иврит (Hebrew)
`G_UNICODE_SCRIPT_HIRAGANA`	Хирагана (Hiragana)
`G_UNICODE_SCRIPT_KANNADA`	Канада (Kannada)
`G_UNICODE_SCRIPT_KATAKANA`	Японская слоговая азбука катакана (Katakana)
`G_UNICODE_SCRIPT_KHMER`	Кхмер (Khmer)
`G_UNICODE_SCRIPT_LAO`	Лао (Lao)
`G_UNICODE_SCRIPT_LATIN`	Латинский (Latin)
`G_UNICODE_SCRIPT_MALAYALAM`	Малайялам (Malayalam)
`G_UNICODE_SCRIPT_MONGOLIAN`	Монгольский (Mongolian)
`G_UNICODE_SCRIPT_MYANMAR`	Myanmar
`G_UNICODE_SCRIPT_OGHAM`	Огам (Ogham)
`G_UNICODE_SCRIPT_OLD_ITALIC`	Староитальянский (Old Italic)
`G_UNICODE_SCRIPT_ORIYA`	Язык ория (Oriya)
`G_UNICODE_SCRIPT_RUNIC`	Руническое письмо (Runic)
`G_UNICODE_SCRIPT_SINHALA`	Сингальский язык (Sinhala)
`G_UNICODE_SCRIPT_SYRIAC`	Сирийский язык (Syriac)
`G_UNICODE_SCRIPT_TAMIL`	Тамильский язык (Tamil)
`G_UNICODE_SCRIPT_TELUGU`	Язык телугу (Telugu)
`G_UNICODE_SCRIPT_THAANA`	Таана (Thaana)
`G_UNICODE_SCRIPT_THAI`	Тайский язык (Thai)
`G_UNICODE_SCRIPT_TIBETAN`	Тибетский (Tibetan)
`G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL`	Канадский язык аборигенов (Canadian Aboriginal)
`G_UNICODE_SCRIPT_YI`	Идиш (Yi)
`G_UNICODE_SCRIPT_TAGALOG`	Тагальский язык (Tagalog)
`G_UNICODE_SCRIPT_HANUNOO`	Hanunoo
`G_UNICODE_SCRIPT_BUHID`	Buhid
`G_UNICODE_SCRIPT_TAGBANWA`	Tagbanwa
`G_UNICODE_SCRIPT_BRAILLE`	Шрифт Брайля (Braille)
`G_UNICODE_SCRIPT_CYPRIOT`	Киприотский (Cypriot)
`G_UNICODE_SCRIPT_LIMBU`	Limbu
`G_UNICODE_SCRIPT_OSMANYA`	Сомалийский алфавит (Osmanya)
`G_UNICODE_SCRIPT_SHAVIAN`	Shavian
`G_UNICODE_SCRIPT_LINEAR_B`	Линейный B (Linear B)
`G_UNICODE_SCRIPT_TAI_LE`	Tai Le
`G_UNICODE_SCRIPT_UGARITIC`	Ugaritic
`G_UNICODE_SCRIPT_NEW_TAI_LUE`	New Tai Lue
`G_UNICODE_SCRIPT_BUGINESE`	Buginese
`G_UNICODE_SCRIPT_GLAGOLITIC`	Glagolitic
`G_UNICODE_SCRIPT_TIFINAGH`	Tifinagh
`G_UNICODE_SCRIPT_SYLOTI_NAGRI`	Syloti Nagri
`G_UNICODE_SCRIPT_OLD_PERSIAN`	Старый персидский (Old Persian)
`G_UNICODE_SCRIPT_KHAROSHTHI`	Kharoshthi
`G_UNICODE_SCRIPT_UNKNOWN`	неизвестный указатель кода
`G_UNICODE_SCRIPT_BALINESE`	Балинизиский (Balinese)
`G_UNICODE_SCRIPT_CUNEIFORM`	Cuneiform
`G_UNICODE_SCRIPT_PHOENICIAN`	Финский (Phoenician)
`G_UNICODE_SCRIPT_PHAGS_PA`	Phags-pa
`G_UNICODE_SCRIPT_NKO`	N'Ko

g_unichar_get_script ()

GUnicodeScript g_unichar_get_script (gunichar ch);

Находит GUnicodeScript для специфического символа (как определено в Unicode Standard Annex 24). Проверка на правильность ch для Unicode символа не производится; если вы поместите недопустимый символ, результат будет неопределённым.

`ch` :	Unicode символ
Возвращает :	GUnicodeScript для символа.

Начиная с версии 2.14

g_utf8_next_char()

#define g_utf8_next_char(p)

Пропускает следующий символ в UTF-8 строке. Строка должна быть допустимой; это максимально быстрая макрокоманда и никакого контроля ошибок не проводится. Вы должны использовать эту макрокоманду для посимвольной итерации строки. Эта макрокоманда возвращает начало следующего символа UTF-8. Перед использованием этой макрокоманды используйте g_utf8_validate() для проверки правильности строк которые могут содержать недопустимые символы UTF-8.

p : указатель на начало допустимого символа UTF-8.

g_utf8_get_char ()

gunichar g_utf8_get_char (const gchar *p);

Конвертирует последовательность байт в кодировке UTF-8 в Unicode символ. Если p не указывает на допустимый символ в кодировке UTF-8, результат будет неопределённым. Если вы не уверены в том что последовательность байт является допустимым кодом Unicode символов, вы должны использовать вместо этой функции g_utf8_get_char_validated().

`p` :	указатель на Unicode символ в кодировке UTF-8
Возвращает :	результирующий символ

g_utf8_get_char_validated ()

gunichar    g_utf8_get_char_validated       (const gchar *p,
                                             gssize max_len);

Конвертирует последовательность байт в кодировке UTF-8 в Unicode символ. Эта функция проверяет незаконченность символов, для недопустимых символов таких как символы которые выходят за диапазон Unicode и слишком длинных допустимых символов.

`p` :	указатель на Unicode символ в кодировке UTF-8
`max_len` :	максимальное количество байт для чтения, или -1, если нет максимума.
Возвращает :	результирующий символ. Если `p` указатель на часть последовательности конца строки которая могла начать допустимый символ, возвращается (gunichar)-2; иначе, если `p` не является указателем на допустимый в UTF-8 кодировке Unicode символ, возвращается (gunichar)-1.

g_utf8_offset_to_pointer ()

gchar*      g_utf8_offset_to_pointer        (const gchar *str,
                                             glong offset);

Конвертирует из целочисленного символа смещения в указатель на позицию внутри строки.

Начиная с версии 2.10, эта функция позволяет помещать отрицательное offset для смещения назад. Это в основном полезно при движении с конца вместо движения вперед если offset это последняя четверть строки, так как передвижение вперёд в три раза быстрее чем назад.

`str` :	строка в кодировке UTF-8
`offset` :	символьное смещение внутри строки `str`
Возвращает :	результирующий указатель

g_utf8_pointer_to_offset ()

glong       g_utf8_pointer_to_offset        (const gchar *str,
                                             const gchar *pos);

Конвертирует из указателя внутри строки в целочисленное смещение символов.

Начиная с версии 2.10, эта функция позволяет pos быть перед str, и возвращает негативное смещение в этом случае.

`str` :	строка в кодировке UTF-8
`pos` :	указатель на позицию внутри `str`
Возвращает :	результирующее символьное смещение

g_utf8_prev_char ()

gchar* g_utf8_prev_char (const gchar *p);

Находит предыдущий символ UTF-8 в строке перед p.

p не должен быть в начале символа UTF-8. Никакая проверка не проводится для найденого символа кроме фактической допустимости начального байта. Если p может оказаться первым символом строки, вы должны использовать g_utf8_find_prev_char() вместо этой функции.

`p` :	указатель на позицию в UTF-8 строке
Возвращает :	указатель на найденный символ.

g_utf8_find_next_char ()

gchar*      g_utf8_find_next_char           (const gchar *p,
                                             const gchar *end);

Ищет начало следующего символа UTF-8 в строке после p.

p не должен быть началом UTF-8 символа. Для найденного символа не проводится никакой проверки фактической правильности символа, кроме допустимости начального байта.

`p` :	указатель на позицию внутри строки UTF-8
`end` :	указатель на конец строки, или `NULL` для указания что строка nul-завершённая, в этом случае он будет возвращённым значением
Возвращает :	указатель на найденный символ или `NULL`

g_utf8_find_prev_char ()

gchar*      g_utf8_find_prev_char           (const gchar *str,
                                             const gchar *p);

Учитывая позицию p со строкой UTF-8 str, находит начало предыдущего символа UTF-8 строки перед p. Возвращает NULL если нет символов UTF-8 представленных в строке str перед p.

p не должен быть началом UTF-8 символа. Никакой проверки не проводится для найденного символа за исключением соответствия начального байта.

`str` :	указатель на начало строки UTF-8
`p` :	указатель на некоторую позицию внутри строки `str`
Возвращает :	указатель на найденный символ или `NULL`.

g_utf8_strlen ()

glong       g_utf8_strlen                   (const gchar *p,
                                             gssize max);

Возвращает длину строки в символах.

`p` :	указатель на начало строки UTF-8.
`max` :	максимальное число байт для проверки. Если `max` меньше чем 0, то строка предположительно будет nul-завершённой. Если `max` это 0, `p` не будет проверен и может быть `NULL`.
Возвращает :	длина строки в символах

g_utf8_strncpy ()

gchar*      g_utf8_strncpy                  (gchar *dest,
                                             const gchar *src,
                                             gsize n);

Как стандартная C функция strncpy(), но копирует полученное количество символов а не байт. Строка src должна быть допустимым UTF-8 текстом. (Используйте g_utf8_validate() для всех текстов перед попыткой использования UTF-8 функций.)

`dest` :	буфер для заполнения символами из `src`
`src` :	строка в кодировке UTF-8
`n` :	количество символов
Возвращает :	`dest`

g_utf8_strchr ()

gchar*      g_utf8_strchr                   (const gchar *p,
                                             gssize len,
                                             gunichar c);

Находит крайнее левое появление полученного символа Unicode в строке UTF-8, ограничивая поиск в len байт. Если len равен -1, допускается неограниченный поиск.

`p` :	nul-завершённая строка UTF-8
`len` :	максимальная длина `p`
`c` :	Unicode символ
Возвращает :	`NULL` если строка не содержит символ, иначе, указатель на начало крайнего левого появления символа в строке.

g_utf8_strrchr ()

gchar*      g_utf8_strrchr                  (const gchar *p,
                                             gssize len,
                                             gunichar c);

Находит крайний правый полученный Unicode символ в строке UTF-8, поиск ограничивается len байтами. Если len это -1, допускается неограниченный поиск.

`p` :	nul-завершённая строка UTF-8
`len` :	максимальная длина `p`
`c` :	Unicode символ
Возвращает :	`NULL` если строка не содержит символа, иначе, указатель на начало крайнего правого появления символа в строке.

g_utf8_strreverse ()

gchar*      g_utf8_strreverse               (const gchar *str,
                                             gssize len);

Переворачивает строку в кодировке UTF-8. str должна быть допустимым текстом в кодировке UTF-8. (Используйте g_utf8_validate() для всех текстов перед попыткой использования сервисных функций UTF-8.)

Помните что в отличие от g_strreverse(), эта функция возвращает вновь распределённую память, которая должна быть освобождена с помощью g_free() когда больше не нужна.

`str` :	строка в кодировке UTF-8
`len` :	максимальная длина `str` для использования. Если `len` < 0, то строка nul-завершённая.
Возвращает :	вновь распределённая строка которая является перевёрнутой строкой `str`.

Начиная с версии 2.2

g_utf8_validate ()

gboolean    g_utf8_validate                 (const gchar *str,
                                             gssize max_len,
                                             const gchar **end);

Утверждает правильность текста в кодировке UTF-8. str это текст для подтверждения; если str nul-завершённая, то max_len может быть -1, иначе max_len должен быть количеством байт для подтверждения. Если end это non-NULL, то конец подтверждённого диапазона будет сохранён здесь (то есть начало первого недопустимого символа, если некоторые байты недопустимы, или иначе конец подтверждённого текста).

Помните что g_utf8_validate() возвращает FALSE если max_len положительное и NUL был встречен перед прочтением max_len байт.

Возвращает TRUE если вся str была допустимой. Многие GLib и GTK+ подпрограммы требуют допустимого ввода UTF-8; поэтому данные прочтённые из файла или сети должны быть проверены с помощью g_utf8_validate() перед выполнением других действий с ними.

`str` :	указатель на символьные данные
`max_len` :	максимальное количество байт для подтверждения, или -1 чтобы действовать пока не встретится NUL
`end` :	расположение для возвращаемого конца подтверждённых данных
Возвращает :	`TRUE` если текст соответствует кодировке UTF-8

g_utf8_strup ()

gchar*      g_utf8_strup                    (const gchar *str,
                                             gssize len);

Конвертирует все Unicode символы строки в верхний регистр. Точный способ которым это выполняется зависит от текущей локали, и может привести к увеличению количества символов в строке. (Например, немецкая ess-zet будет изменена на SS.)

`str` :	строка в кодировке UTF-8
`len` :	длина `str`, в байтах, или -1 если `str` nul-завершённая.
Возвращает :	вновь распределённая строка, все символы которой конвертированы в верхний регистр.

g_utf8_strdown ()

gchar*      g_utf8_strdown                  (const gchar *str,
                                             gssize len);

Конвертирует все Unicode символы строки в нижний регистр. Точный способ которым это выполняется зависит от текущей локали, и может привести к изменению количества символов в строке.

`str` :	строка в кодировке UTF-8
`len` :	длина `str`, в байтах, или -1 если `str` nul-завершённая.
Возвращает :	вновь распределённая строка, в которой все символы конвертированы в нижний регистр.

g_utf8_casefold ()

gchar*      g_utf8_casefold                 (const gchar *str,
                                             gssize len);

Конвертирует строку в форму которая не зависит от регистра. Результат не будет соответствовать никакому специальному регистру, но может быть сравнен для равенства или упорядочен с результатом вызова g_utf8_casefold() для других строк.

Помните что вызов g_utf8_casefold() сопровождаемый g_utf8_collate() только приближает к правильному лингвистическому регистру нечувствительному к упорядочиванию, однако это достаточно хорошо. Получение более точного и правильного результата требует более сложной функции сопоставления которая принимает во внимание чувствительность к регистру. GLib в настоящее время не поддерживает такую функцию.

`str` :	строка в кодировке UTF-8
`len` :	длина `str`, в байтах, или -1 если `str` nul-завершённая.
Возвращает :	вновь распределённая строка, которая является регистронезависимой `str`.

g_utf8_normalize ()

gchar*      g_utf8_normalize                (const gchar *str,
                                             gssize len,
                                             GNormalizeMode mode);

Конвертирует строку в изначальную форму, стандартизируя такие проблемы как, представлен ли символ с акцентом как основной и комбинирующий акцент, или как единственный составной символ. В основном вы должны вызвать g_utf8_normalize() перед сравнением двух Unicode строк.

Режим нормализации G_NORMALIZE_DEFAULT только стандартизирует различия которые не затрагивают текстовое содержание, такие как упомянутые выше акценты представления. G_NORMALIZE_ALL также стандартизирует символы "совместимости" в Unicode, такие как SUPERSCRIPT THREE в стандартные формы (в данном случае DIGIT THREE). Форматирование информации может быть потеряно но в большинстве текстовых операций такие символы должны быть рассмотрены одинаково. Например, g_utf8_collate() нормализуется с помощью G_NORMALIZE_ALL как первый шаг.

G_NORMALIZE_DEFAULT_COMPOSE и G_NORMALIZE_ALL_COMPOSE являются подобными G_NORMALIZE_DEFAULT и G_NORMALIZE_ALL, но возвращают результат с составными формами а не в максимально разложенной форме. Это часто полезно если вы хотите преобразовать строку в устаревшую кодировку или поместить её в систему с меньшей способностью обрабатывать Unicode.

`str` :	строка в кодировке UTF-8.
`len` :	длина `str`, в байтах, или -1 если `str` nul-завершённая.
`mode` :	тип выполняемой нормализации.
Возвращает :	вновь распределённая строка, которая представляет нормализованную форму `str`.

enum GNormalizeMode

typedef enum {
  G_NORMALIZE_DEFAULT,
  G_NORMALIZE_NFD = G_NORMALIZE_DEFAULT,
  G_NORMALIZE_DEFAULT_COMPOSE,
  G_NORMALIZE_NFC = G_NORMALIZE_DEFAULT_COMPOSE,
  G_NORMALIZE_ALL,
  G_NORMALIZE_NFKD = G_NORMALIZE_ALL,
  G_NORMALIZE_ALL_COMPOSE,
  G_NORMALIZE_NFKC = G_NORMALIZE_ALL_COMPOSE
} GNormalizeMode;

Определяет как трансформировать Unicode строку в каноническую форму, стандартизирует такие проблемы как представлен ли символ с акцентом основного символа и акцентом комбинирования или как единственный составной символ. Unicode строки должны в основном быть нормализованы после их сравнения.

`G_NORMALIZE_DEFAULT`	стандартизирует различия которые не затрагивают текстовое содержимое, такие как описанный выше метод представления акцента.
`G_NORMALIZE_NFD`	другое имя для `G_NORMALIZE_DEFAULT`.
`G_NORMALIZE_DEFAULT_COMPOSE`	тоже что `G_NORMALIZE_DEFAULT`, но с составными формами вместо максимально разложенных форм.
`G_NORMALIZE_NFC`	другое имя для `G_NORMALIZE_DEFAULT_COMPOSE`.
`G_NORMALIZE_ALL`	помимо `G_NORMALIZE_DEFAULT` также стандартизирует символы "совместимости" в Unicode, такие как SUPERSCRIPT THREE для стандартных форм (в этом случае DIGIT THREE). Форматирование информации может быть нарушено, но для большинства текстовых операций такие символы должны быть рассмотрены одинаково.
`G_NORMALIZE_NFKD`	другое имя для `G_NORMALIZE_ALL`.
`G_NORMALIZE_ALL_COMPOSE`	аналогично `G_NORMALIZE_ALL`, но с составными формами вместо максимально разложенных форм.
`G_NORMALIZE_NFKC`	другое имя для `G_NORMALIZE_ALL_COMPOSE`.

g_utf8_collate ()

gint        g_utf8_collate                  (const gchar *str1,
                                             const gchar *str2);

Сравнивает две строки для правильного использования лингвистических правил текущей локали. Сортируя большое количество строк, она будет значительно быстрее определять ключи сопоставления с помощью g_utf8_collate_key() и сравнивать ключи и сортируя с помощью strcmp(), вместо сортировки оригинальных строк.

`str1` :	строка в кодировке UTF-8
`str2` :	строка в кодировке UTF-8
Возвращает :	< 0 если `str1` сравнивается перед `str2`, 0 если сравнение эквивалентно, > 0 если `str1` сравнивается после `str2`.

g_utf8_collate_key ()

gchar*      g_utf8_collate_key              (const gchar *str,
                                             gssize len);

Конвертирует строку в ключ сопоставления который можно сравнить с другим ключом сравнения произведенным той же функцией используя strcmp(). Результат сравнения ключей сопоставления двух строк с помощью strcmp() всегда будет сопоставим с результатом сравнения оригинальных ключей с помощью g_utf8_collate().

`str` :	строка в кодировке UTF-8.
`len` :	длина `str`, в байтах, или -1 если `str` nul-завершённая.
Возвращает :	вновь распределённая строка. Эта строка должна быть освобождена с помощью `g_free()` когда больше не нужна.

g_utf8_collate_key_for_filename ()

gchar*      g_utf8_collate_key_for_filename (const gchar *str,
                                             gssize len);

Конвертирует строку в ключ сопоставления который можно сравнить с другим ключом произведённым этой же функцией с помощью strcmp().

Для правильной сортировки имён файлов, эта функция обрабатывает точку '.' как специфичный случай. Большинство словарей считают это незначительным, производя таким образом порядок "event.c" "eventgenerator.c" "event.h" вместо "event.c" "event.h" "eventgenerator.c". Кроме того, хотелось бы обрабатывать разумно числа, так чтобы "file1" "file10" "file5" сортировались как "file1" "file5" "file10".

`str` :	строка в кодировке UTF-8.
`len` :	длина `str`, в байтах, или -1 если `str` nul-завершённая.
Возвращает :	вновь распределённая строка. Эта строка должна быть освобождена с помощью `g_free()` когда больше не нужна.

Начиная с версии 2.8

g_utf8_to_utf16 ()

gunichar2*  g_utf8_to_utf16                 (const gchar *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);

Конвертирует строку из UTF-8 в UTF-16. Символ 0 будет добавлен к результату после конвертации текста.

`str` :	строка в кодировке UTF-8
`len` :	максимальная длина (количество символов) `str` для использования. Если `len` < 0, то строка nul-завершённая.
`items_read` :	расположение для хранения количества прочтённых байт, или `NULL`. Если `NULL`, то `G_CONVERT_ERROR_PARTIAL_INPUT` будет возвращён в случае, если `str` содержит завершённый частично символ. Если произошла ошибка, то здесь сохраняется индекс недопустимого ввода.
`items_written` :	расположение для хранения записанного числа gunichar2, или `NULL`. Значение сохраняемое здесь не включает завершающий 0.
`error` :	расположение для хранения произошедшей ошибки, или `NULL` для игнорирования ошибок. Могут происходить любые ошибки из GConvertError кроме `G_CONVERT_ERROR_NO_CONVERSION`.
Возвращает :	указатель на вновь распределённую строку UTF-16. Это значение может быть освобождено с помощью `g_free()`. Если произошла ошибка, `NULL` будет возвращён и установлена `error`.

g_utf8_to_ucs4 ()

gunichar*   g_utf8_to_ucs4                  (const gchar *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);

Конвертирует строку из UTF-8 в 32-bit фиксированной ширины представленный как UCS-4. Заверщающий 0 будет добавлен к строке после конвертации текста.

`str` :	строка в кодировке UTF-8
`len` :	максимальная длина `str` для использования. Если `len` < 0, то строка nul-завершённая.
`items_read` :	расположение для хранения прочитанных байт, или `NULL`. Если `NULL`, то `G_CONVERT_ERROR_PARTIAL_INPUT` будет возвращён в случае, если `str` содержит завершающую часть символа. Если произошла ошибка, то здесь сохраняется индекс недопустимого ввода.
`items_written` :	расположение для хранения записанных символов или `NULL`. Значение сохраняемое здесь не включает завершающий символ 0.
`error` :	расположение для хранения произошедшей ошибки, или `NULL` для игнорирования ошибок. Могут произойти любые ошибки из GConvertError кроме `G_CONVERT_ERROR_NO_CONVERSION`.
Возвращает :	указатель на вновь распределённую строку UCS-4. Это значение должно быть освобождено с помощью `g_free()`. Если произошла ошибка, то возвращается `NULL` и устанавливается `error`.

g_utf8_to_ucs4_fast ()

gunichar*   g_utf8_to_ucs4_fast             (const gchar *str,
                                             glong len,
                                             glong *items_written);

Конвертирует строку из UTF-8 в 32-bit представление фиксированной ширины UCS-4, принимая правильный ввод UTF-8. Эта функция примерно в два раза быстрее чем g_utf8_to_ucs4(), но не производит никакой проверки ошибок ввода.

`str` :	строка в кодировке UTF-8
`len` :	максимальная длина `str` для использования. Если `len` < 0, то строка nul-завершённая.
`items_written` :	расположение для хранения количества символов в результате, или `NULL`.
Возвращает :	указатель на вновь распределённую строку UCS-4. Это значение должно быть освобождено с помощью `g_free()`.

g_utf16_to_ucs4 ()

gunichar*   g_utf16_to_ucs4                 (const gunichar2 *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);

Конвертирует строку из UTF-16 в UCS-4. Результат будет завершён символом 0.

`str` :	строка в кодировке UTF-16
`len` :	максимальная длина (число gunichar2) `str` для использования. Если `len` < 0, то строка завершается символом 0.
`items_read` :	расположение для хранения прочтенных слов, или `NULL`. Если `NULL`, то `G_CONVERT_ERROR_PARTIAL_INPUT` будет возвращён в случае, если `str` содержит часть завершающего символа. Если произошла ошибка то здесь сохраняется индекс недопустимого ввода.
`items_written` :	расположение для хранения количества записанных символов, или `NULL`. Значение сохраняемое здесь не включает завершающий символ 0.
`error` :	расположение для хранения произошедшей ошибки, или `NULL` для игнорирования ошибок. Могут произойти любые ошибки из GConvertError кроме `G_CONVERT_ERROR_NO_CONVERSION`.
Возвращает :	указатель на вновь распределённую строку UCS-4. Это значение должно быть освобождено с помощью `g_free()`. Если произошла ошибка, то возврашается `NULL` и устанавливается `error`.

g_utf16_to_utf8 ()

gchar*      g_utf16_to_utf8                 (const gunichar2 *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);

Конвертирует строку из UTF-16 в UTF-8. Результат будет завершён 0 байтом.

Помните что ввод находится уже в родном порядке байт (endianness), начальный символ byte-order-mark специально не обрабатывается. g_convert() может быть использована для конвертации буфера байт данных UTF-16 неоднозначного порядка байт (endianess).

`str` :	строка в кодировке UTF-16
`len` :	максимальная длина (число gunichar2) `str` для использования. Если `len` < 0, то строка завершается символом 0.
`items_read` :	расположение для хранения количества прочитанных слов, или `NULL`. Если `NULL`, то `G_CONVERT_ERROR_PARTIAL_INPUT` будет возвращено в случае, если `str` содержит часть завершающего символа. Если произошла ошибка то здесь сохраняется индекс недопустимого ввода.
`items_written` :	расположение для хранения количества записанных байт, или `NULL`. Значение записанное здесь не включает завершающий 0 байт.
`error` :	расположение для хранения произошедшей ошибки, или `NULL` для игнорирования ошибок. Могут произойти любые ошибки из GConvertError кроме `G_CONVERT_ERROR_NO_CONVERSION`.
Возвращает :	указатель на вновь распределённую строку UTF-8. Это значение должно быть освобождено с помощью `g_free()`. Если произошла ошибка, `NULL` будет возвращён и установлена `error`.

g_ucs4_to_utf16 ()

gunichar2*  g_ucs4_to_utf16                 (const gunichar *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);

Конвертирует строку из UCS-4 в UTF-16. Символ 0 будет добавлен к результату после конвертации текста.

`str` :	строка в кодировке UCS-4
`len` :	максимальная длина (число символов) `str` для использования. Если `len` < 0, то строка завершается символом 0.
`items_read` :	расположение для хранения количества прочитанных байт, или `NULL`. Если произошла ошибка то здесь сохраняется индекс недопустимого ввода.
`items_written` :	расположение для хранения числа gunichar2 записей, или `NULL`. Значение сохраняемое здесь не включает завершающий 0.
`error` :	расположение для хранения произошедшей ошибки, или `NULL` для игнорирования ошибок. Могут произойти любые ошибки из GConvertError кроме `G_CONVERT_ERROR_NO_CONVERSION`.
Возвращает :	указатель на вновь распределённую строку UTF-16. Это значение должно быть освобождено с помощью `g_free()`. Если произошла ошибка, `NULL` будет возвращён и установлена `error`.

g_ucs4_to_utf8 ()

gchar*      g_ucs4_to_utf8                  (const gunichar *str,
                                             glong len,
                                             glong *items_read,
                                             glong *items_written,
                                             GError **error);

Конвертирует строку из 32-bit фиксированной ширины представленной как UCS-4. в UTF-8. Результат будет завершён 0 байтом.

`str` :	строка в кодировке UCS-4
`len` :	максимальная длина (количество символов) `str` для использования. Если `len` < 0, то строка завершается 0 символом.
`items_read` :	расположение для хранения количества прочитанных символов, или `NULL`.
`items_written` :	расположение для хранения записанных байт или `NULL`. Значение сохраняемое здесь не включает завершающий 0 байт.
`error` :	расположение для хранения произошедшей ошибки, или `NULL` для игнорирования ошибок. Могут происходить любые ошибки из GConvertError кроме `G_CONVERT_ERROR_NO_CONVERSION`.
Возвращает :	указатель на вновь распределённую строку UTF-8. Это значение должно быть освобождено с помощью `g_free()`. Если произошла ошибка, `NULL` будет возвращён и установлена `error`. В этом случае, `items_read` будет установлен в позицию первого недопустимого символа ввода.

g_unichar_to_utf8 ()

gint        g_unichar_to_utf8               (gunichar c,
                                             gchar *outbuf);

Конвертирует единственный символ в UTF-8.

`c` :	символ в кодировке Unicode
`outbuf` :	буфер вывода, должен иметь последние 6 байт свободными. Если `NULL`, то длина будет вычислена и возвращена и ничего не будет записано в буфер `outbuf`.
Возвращает :	количество записанных байт

Удобные функции для конвертации между UTF-8 и локальной кодировкой.

^[3]суррогатные пары

			Справочное описание GLib
Начало \| Описание