The OpenNET Project / Index page

[ новости /+++ | форум | wiki | теги | ]

Каталог документации / Раздел "Программирование, языки" / Оглавление документа

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.
Возвращает : количество записанных байт

Смотрите также

g_locale_to_utf8(), g_locale_from_utf8()

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



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



Спонсоры:
Inferno Solutions
Hosting by Hoster.ru
Хостинг:

Закладки на сайте
Проследить за страницей
Created 1996-2021 by Maxim Chirkov
Добавить, Поддержать, Вебмастеру