1// Package glib was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package glib
3
4import (
5 "github.com/ebitengine/purego"
6
7 "github.com/bnema/puregotk/pkg/core"
8 "github.com/bnema/puregotk/v4/gobject/types"
9)
10
11const (
12 // The maximum length (in codepoints) of a compatibility or canonical
13 // decomposition of a single Unicode character.
14 //
15 // This is as defined by Unicode 6.1.
16 UNICHAR_MAX_DECOMPOSITION_LENGTH int = 18
17)
18
19// Defines how a Unicode string is transformed in a canonical
20// form, standardizing such issues as whether a character with
21// an accent is represented as a base character and combining
22// accent or as a single precomposed character. Unicode strings
23// should generally be normalized before comparing them.
24type NormalizeMode int
25
26var xNormalizeModeGLibType func() types.GType
27
28func NormalizeModeGLibType() types.GType {
29 return xNormalizeModeGLibType()
30}
31
32const (
33
34 // standardize differences that do not affect the
35 // text content, such as the above-mentioned accent representation
36 GNormalizeDefaultValue NormalizeMode = 0
37 // another name for %G_NORMALIZE_DEFAULT
38 GNormalizeNfdValue NormalizeMode = 0
39 // like %G_NORMALIZE_DEFAULT, but with
40 // composed forms rather than a maximally decomposed form
41 GNormalizeDefaultComposeValue NormalizeMode = 1
42 // another name for %G_NORMALIZE_DEFAULT_COMPOSE
43 GNormalizeNfcValue NormalizeMode = 1
44 // beyond %G_NORMALIZE_DEFAULT also standardize the
45 // "compatibility" characters in Unicode, such as SUPERSCRIPT THREE
46 // to the standard forms (in this case DIGIT THREE). Formatting
47 // information may be lost but for most text operations such
48 // characters should be considered the same
49 GNormalizeAllValue NormalizeMode = 2
50 // another name for %G_NORMALIZE_ALL
51 GNormalizeNfkdValue NormalizeMode = 2
52 // like %G_NORMALIZE_ALL, but with composed
53 // forms rather than a maximally decomposed form
54 GNormalizeAllComposeValue NormalizeMode = 3
55 // another name for %G_NORMALIZE_ALL_COMPOSE
56 GNormalizeNfkcValue NormalizeMode = 3
57)
58
59// These are the possible line break classifications.
60//
61// Since new Unicode versions may add new types here, applications should be ready
62// to handle unknown values. They may be regarded as %G_UNICODE_BREAK_UNKNOWN.
63//
64// See [Unicode Line Breaking Algorithm](https://www.unicode.org/reports/tr14/).
65type UnicodeBreakType int
66
67var xUnicodeBreakTypeGLibType func() types.GType
68
69func UnicodeBreakTypeGLibType() types.GType {
70 return xUnicodeBreakTypeGLibType()
71}
72
73const (
74
75 // Mandatory Break (BK)
76 GUnicodeBreakMandatoryValue UnicodeBreakType = 0
77 // Carriage Return (CR)
78 GUnicodeBreakCarriageReturnValue UnicodeBreakType = 1
79 // Line Feed (LF)
80 GUnicodeBreakLineFeedValue UnicodeBreakType = 2
81 // Attached Characters and Combining Marks (CM)
82 GUnicodeBreakCombiningMarkValue UnicodeBreakType = 3
83 // Surrogates (SG)
84 GUnicodeBreakSurrogateValue UnicodeBreakType = 4
85 // Zero Width Space (ZW)
86 GUnicodeBreakZeroWidthSpaceValue UnicodeBreakType = 5
87 // Inseparable (IN)
88 GUnicodeBreakInseparableValue UnicodeBreakType = 6
89 // Non-breaking ("Glue") (GL)
90 GUnicodeBreakNonBreakingGlueValue UnicodeBreakType = 7
91 // Contingent Break Opportunity (CB)
92 GUnicodeBreakContingentValue UnicodeBreakType = 8
93 // Space (SP)
94 GUnicodeBreakSpaceValue UnicodeBreakType = 9
95 // Break Opportunity After (BA)
96 GUnicodeBreakAfterValue UnicodeBreakType = 10
97 // Break Opportunity Before (BB)
98 GUnicodeBreakBeforeValue UnicodeBreakType = 11
99 // Break Opportunity Before and After (B2)
100 GUnicodeBreakBeforeAndAfterValue UnicodeBreakType = 12
101 // Hyphen (HY)
102 GUnicodeBreakHyphenValue UnicodeBreakType = 13
103 // Nonstarter (NS)
104 GUnicodeBreakNonStarterValue UnicodeBreakType = 14
105 // Opening Punctuation (OP)
106 GUnicodeBreakOpenPunctuationValue UnicodeBreakType = 15
107 // Closing Punctuation (CL)
108 GUnicodeBreakClosePunctuationValue UnicodeBreakType = 16
109 // Ambiguous Quotation (QU)
110 GUnicodeBreakQuotationValue UnicodeBreakType = 17
111 // Exclamation/Interrogation (EX)
112 GUnicodeBreakExclamationValue UnicodeBreakType = 18
113 // Ideographic (ID)
114 GUnicodeBreakIdeographicValue UnicodeBreakType = 19
115 // Numeric (NU)
116 GUnicodeBreakNumericValue UnicodeBreakType = 20
117 // Infix Separator (Numeric) (IS)
118 GUnicodeBreakInfixSeparatorValue UnicodeBreakType = 21
119 // Symbols Allowing Break After (SY)
120 GUnicodeBreakSymbolValue UnicodeBreakType = 22
121 // Ordinary Alphabetic and Symbol Characters (AL)
122 GUnicodeBreakAlphabeticValue UnicodeBreakType = 23
123 // Prefix (Numeric) (PR)
124 GUnicodeBreakPrefixValue UnicodeBreakType = 24
125 // Postfix (Numeric) (PO)
126 GUnicodeBreakPostfixValue UnicodeBreakType = 25
127 // Complex Content Dependent (South East Asian) (SA)
128 GUnicodeBreakComplexContextValue UnicodeBreakType = 26
129 // Ambiguous (Alphabetic or Ideographic) (AI)
130 GUnicodeBreakAmbiguousValue UnicodeBreakType = 27
131 // Unknown (XX)
132 GUnicodeBreakUnknownValue UnicodeBreakType = 28
133 // Next Line (NL)
134 GUnicodeBreakNextLineValue UnicodeBreakType = 29
135 // Word Joiner (WJ)
136 GUnicodeBreakWordJoinerValue UnicodeBreakType = 30
137 // Hangul L Jamo (JL)
138 GUnicodeBreakHangulLJamoValue UnicodeBreakType = 31
139 // Hangul V Jamo (JV)
140 GUnicodeBreakHangulVJamoValue UnicodeBreakType = 32
141 // Hangul T Jamo (JT)
142 GUnicodeBreakHangulTJamoValue UnicodeBreakType = 33
143 // Hangul LV Syllable (H2)
144 GUnicodeBreakHangulLvSyllableValue UnicodeBreakType = 34
145 // Hangul LVT Syllable (H3)
146 GUnicodeBreakHangulLvtSyllableValue UnicodeBreakType = 35
147 // Closing Parenthesis (CP). Since 2.28. Deprecated: 2.70: Use %G_UNICODE_BREAK_CLOSE_PARENTHESIS instead.
148 GUnicodeBreakCloseParanthesisValue UnicodeBreakType = 36
149 // Closing Parenthesis (CP). Since 2.70
150 GUnicodeBreakCloseParenthesisValue UnicodeBreakType = 36
151 // Conditional Japanese Starter (CJ). Since: 2.32
152 GUnicodeBreakConditionalJapaneseStarterValue UnicodeBreakType = 37
153 // Hebrew Letter (HL). Since: 2.32
154 GUnicodeBreakHebrewLetterValue UnicodeBreakType = 38
155 // Regional Indicator (RI). Since: 2.36
156 GUnicodeBreakRegionalIndicatorValue UnicodeBreakType = 39
157 // Emoji Base (EB). Since: 2.50
158 GUnicodeBreakEmojiBaseValue UnicodeBreakType = 40
159 // Emoji Modifier (EM). Since: 2.50
160 GUnicodeBreakEmojiModifierValue UnicodeBreakType = 41
161 // Zero Width Joiner (ZWJ). Since: 2.50
162 GUnicodeBreakZeroWidthJoinerValue UnicodeBreakType = 42
163 // Aksara (AK). Since: 2.80
164 GUnicodeBreakAksaraValue UnicodeBreakType = 43
165 // Aksara Pre-Base (AP). Since: 2.80
166 GUnicodeBreakAksaraPreBaseValue UnicodeBreakType = 44
167 // Aksara Start (AS). Since: 2.80
168 GUnicodeBreakAksaraStartValue UnicodeBreakType = 45
169 // Virama Final (VF). Since: 2.80
170 GUnicodeBreakViramaFinalValue UnicodeBreakType = 46
171 // Virama (VI). Since: 2.80
172 GUnicodeBreakViramaValue UnicodeBreakType = 47
173)
174
175// The #GUnicodeScript enumeration identifies different writing
176// systems. The values correspond to the names as defined in the
177// Unicode standard. The enumeration has been added in GLib 2.14,
178// and is interchangeable with #PangoScript.
179//
180// Note that new types may be added in the future. Applications
181// should be ready to handle unknown values.
182// See [Unicode Standard Annex #24: Script names](http://www.unicode.org/reports/tr24/).
183type UnicodeScript int
184
185var xUnicodeScriptGLibType func() types.GType
186
187func UnicodeScriptGLibType() types.GType {
188 return xUnicodeScriptGLibType()
189}
190
191const (
192
193 // a value never returned from g_unichar_get_script()
194 GUnicodeScriptInvalidCodeValue UnicodeScript = -1
195 // a character used by multiple different scripts
196 GUnicodeScriptCommonValue UnicodeScript = 0
197 // a mark glyph that takes its script from the
198 // base glyph to which it is attached
199 GUnicodeScriptInheritedValue UnicodeScript = 1
200 // Arabic
201 GUnicodeScriptArabicValue UnicodeScript = 2
202 // Armenian
203 GUnicodeScriptArmenianValue UnicodeScript = 3
204 // Bengali
205 GUnicodeScriptBengaliValue UnicodeScript = 4
206 // Bopomofo
207 GUnicodeScriptBopomofoValue UnicodeScript = 5
208 // Cherokee
209 GUnicodeScriptCherokeeValue UnicodeScript = 6
210 // Coptic
211 GUnicodeScriptCopticValue UnicodeScript = 7
212 // Cyrillic
213 GUnicodeScriptCyrillicValue UnicodeScript = 8
214 // Deseret
215 GUnicodeScriptDeseretValue UnicodeScript = 9
216 // Devanagari
217 GUnicodeScriptDevanagariValue UnicodeScript = 10
218 // Ethiopic
219 GUnicodeScriptEthiopicValue UnicodeScript = 11
220 // Georgian
221 GUnicodeScriptGeorgianValue UnicodeScript = 12
222 // Gothic
223 GUnicodeScriptGothicValue UnicodeScript = 13
224 // Greek
225 GUnicodeScriptGreekValue UnicodeScript = 14
226 // Gujarati
227 GUnicodeScriptGujaratiValue UnicodeScript = 15
228 // Gurmukhi
229 GUnicodeScriptGurmukhiValue UnicodeScript = 16
230 // Han
231 GUnicodeScriptHanValue UnicodeScript = 17
232 // Hangul
233 GUnicodeScriptHangulValue UnicodeScript = 18
234 // Hebrew
235 GUnicodeScriptHebrewValue UnicodeScript = 19
236 // Hiragana
237 GUnicodeScriptHiraganaValue UnicodeScript = 20
238 // Kannada
239 GUnicodeScriptKannadaValue UnicodeScript = 21
240 // Katakana
241 GUnicodeScriptKatakanaValue UnicodeScript = 22
242 // Khmer
243 GUnicodeScriptKhmerValue UnicodeScript = 23
244 // Lao
245 GUnicodeScriptLaoValue UnicodeScript = 24
246 // Latin
247 GUnicodeScriptLatinValue UnicodeScript = 25
248 // Malayalam
249 GUnicodeScriptMalayalamValue UnicodeScript = 26
250 // Mongolian
251 GUnicodeScriptMongolianValue UnicodeScript = 27
252 // Myanmar
253 GUnicodeScriptMyanmarValue UnicodeScript = 28
254 // Ogham
255 GUnicodeScriptOghamValue UnicodeScript = 29
256 // Old Italic
257 GUnicodeScriptOldItalicValue UnicodeScript = 30
258 // Oriya
259 GUnicodeScriptOriyaValue UnicodeScript = 31
260 // Runic
261 GUnicodeScriptRunicValue UnicodeScript = 32
262 // Sinhala
263 GUnicodeScriptSinhalaValue UnicodeScript = 33
264 // Syriac
265 GUnicodeScriptSyriacValue UnicodeScript = 34
266 // Tamil
267 GUnicodeScriptTamilValue UnicodeScript = 35
268 // Telugu
269 GUnicodeScriptTeluguValue UnicodeScript = 36
270 // Thaana
271 GUnicodeScriptThaanaValue UnicodeScript = 37
272 // Thai
273 GUnicodeScriptThaiValue UnicodeScript = 38
274 // Tibetan
275 GUnicodeScriptTibetanValue UnicodeScript = 39
276 // Canadian Aboriginal
277 GUnicodeScriptCanadianAboriginalValue UnicodeScript = 40
278 // Yi
279 GUnicodeScriptYiValue UnicodeScript = 41
280 // Tagalog
281 GUnicodeScriptTagalogValue UnicodeScript = 42
282 // Hanunoo
283 GUnicodeScriptHanunooValue UnicodeScript = 43
284 // Buhid
285 GUnicodeScriptBuhidValue UnicodeScript = 44
286 // Tagbanwa
287 GUnicodeScriptTagbanwaValue UnicodeScript = 45
288 // Braille
289 GUnicodeScriptBrailleValue UnicodeScript = 46
290 // Cypriot
291 GUnicodeScriptCypriotValue UnicodeScript = 47
292 // Limbu
293 GUnicodeScriptLimbuValue UnicodeScript = 48
294 // Osmanya
295 GUnicodeScriptOsmanyaValue UnicodeScript = 49
296 // Shavian
297 GUnicodeScriptShavianValue UnicodeScript = 50
298 // Linear B
299 GUnicodeScriptLinearBValue UnicodeScript = 51
300 // Tai Le
301 GUnicodeScriptTaiLeValue UnicodeScript = 52
302 // Ugaritic
303 GUnicodeScriptUgariticValue UnicodeScript = 53
304 // New Tai Lue
305 GUnicodeScriptNewTaiLueValue UnicodeScript = 54
306 // Buginese
307 GUnicodeScriptBugineseValue UnicodeScript = 55
308 // Glagolitic
309 GUnicodeScriptGlagoliticValue UnicodeScript = 56
310 // Tifinagh
311 GUnicodeScriptTifinaghValue UnicodeScript = 57
312 // Syloti Nagri
313 GUnicodeScriptSylotiNagriValue UnicodeScript = 58
314 // Old Persian
315 GUnicodeScriptOldPersianValue UnicodeScript = 59
316 // Kharoshthi
317 GUnicodeScriptKharoshthiValue UnicodeScript = 60
318 // an unassigned code point
319 GUnicodeScriptUnknownValue UnicodeScript = 61
320 // Balinese
321 GUnicodeScriptBalineseValue UnicodeScript = 62
322 // Cuneiform
323 GUnicodeScriptCuneiformValue UnicodeScript = 63
324 // Phoenician
325 GUnicodeScriptPhoenicianValue UnicodeScript = 64
326 // Phags-pa
327 GUnicodeScriptPhagsPaValue UnicodeScript = 65
328 // N'Ko
329 GUnicodeScriptNkoValue UnicodeScript = 66
330 // Kayah Li. Since 2.16.3
331 GUnicodeScriptKayahLiValue UnicodeScript = 67
332 // Lepcha. Since 2.16.3
333 GUnicodeScriptLepchaValue UnicodeScript = 68
334 // Rejang. Since 2.16.3
335 GUnicodeScriptRejangValue UnicodeScript = 69
336 // Sundanese. Since 2.16.3
337 GUnicodeScriptSundaneseValue UnicodeScript = 70
338 // Saurashtra. Since 2.16.3
339 GUnicodeScriptSaurashtraValue UnicodeScript = 71
340 // Cham. Since 2.16.3
341 GUnicodeScriptChamValue UnicodeScript = 72
342 // Ol Chiki. Since 2.16.3
343 GUnicodeScriptOlChikiValue UnicodeScript = 73
344 // Vai. Since 2.16.3
345 GUnicodeScriptVaiValue UnicodeScript = 74
346 // Carian. Since 2.16.3
347 GUnicodeScriptCarianValue UnicodeScript = 75
348 // Lycian. Since 2.16.3
349 GUnicodeScriptLycianValue UnicodeScript = 76
350 // Lydian. Since 2.16.3
351 GUnicodeScriptLydianValue UnicodeScript = 77
352 // Avestan. Since 2.26
353 GUnicodeScriptAvestanValue UnicodeScript = 78
354 // Bamum. Since 2.26
355 GUnicodeScriptBamumValue UnicodeScript = 79
356 // Egyptian Hieroglpyhs. Since 2.26
357 GUnicodeScriptEgyptianHieroglyphsValue UnicodeScript = 80
358 // Imperial Aramaic. Since 2.26
359 GUnicodeScriptImperialAramaicValue UnicodeScript = 81
360 // Inscriptional Pahlavi. Since 2.26
361 GUnicodeScriptInscriptionalPahlaviValue UnicodeScript = 82
362 // Inscriptional Parthian. Since 2.26
363 GUnicodeScriptInscriptionalParthianValue UnicodeScript = 83
364 // Javanese. Since 2.26
365 GUnicodeScriptJavaneseValue UnicodeScript = 84
366 // Kaithi. Since 2.26
367 GUnicodeScriptKaithiValue UnicodeScript = 85
368 // Lisu. Since 2.26
369 GUnicodeScriptLisuValue UnicodeScript = 86
370 // Meetei Mayek. Since 2.26
371 GUnicodeScriptMeeteiMayekValue UnicodeScript = 87
372 // Old South Arabian. Since 2.26
373 GUnicodeScriptOldSouthArabianValue UnicodeScript = 88
374 // Old Turkic. Since 2.28
375 GUnicodeScriptOldTurkicValue UnicodeScript = 89
376 // Samaritan. Since 2.26
377 GUnicodeScriptSamaritanValue UnicodeScript = 90
378 // Tai Tham. Since 2.26
379 GUnicodeScriptTaiThamValue UnicodeScript = 91
380 // Tai Viet. Since 2.26
381 GUnicodeScriptTaiVietValue UnicodeScript = 92
382 // Batak. Since 2.28
383 GUnicodeScriptBatakValue UnicodeScript = 93
384 // Brahmi. Since 2.28
385 GUnicodeScriptBrahmiValue UnicodeScript = 94
386 // Mandaic. Since 2.28
387 GUnicodeScriptMandaicValue UnicodeScript = 95
388 // Chakma. Since: 2.32
389 GUnicodeScriptChakmaValue UnicodeScript = 96
390 // Meroitic Cursive. Since: 2.32
391 GUnicodeScriptMeroiticCursiveValue UnicodeScript = 97
392 // Meroitic Hieroglyphs. Since: 2.32
393 GUnicodeScriptMeroiticHieroglyphsValue UnicodeScript = 98
394 // Miao. Since: 2.32
395 GUnicodeScriptMiaoValue UnicodeScript = 99
396 // Sharada. Since: 2.32
397 GUnicodeScriptSharadaValue UnicodeScript = 100
398 // Sora Sompeng. Since: 2.32
399 GUnicodeScriptSoraSompengValue UnicodeScript = 101
400 // Takri. Since: 2.32
401 GUnicodeScriptTakriValue UnicodeScript = 102
402 // Bassa. Since: 2.42
403 GUnicodeScriptBassaVahValue UnicodeScript = 103
404 // Caucasian Albanian. Since: 2.42
405 GUnicodeScriptCaucasianAlbanianValue UnicodeScript = 104
406 // Duployan. Since: 2.42
407 GUnicodeScriptDuployanValue UnicodeScript = 105
408 // Elbasan. Since: 2.42
409 GUnicodeScriptElbasanValue UnicodeScript = 106
410 // Grantha. Since: 2.42
411 GUnicodeScriptGranthaValue UnicodeScript = 107
412 // Kjohki. Since: 2.42
413 GUnicodeScriptKhojkiValue UnicodeScript = 108
414 // Khudawadi, Sindhi. Since: 2.42
415 GUnicodeScriptKhudawadiValue UnicodeScript = 109
416 // Linear A. Since: 2.42
417 GUnicodeScriptLinearAValue UnicodeScript = 110
418 // Mahajani. Since: 2.42
419 GUnicodeScriptMahajaniValue UnicodeScript = 111
420 // Manichaean. Since: 2.42
421 GUnicodeScriptManichaeanValue UnicodeScript = 112
422 // Mende Kikakui. Since: 2.42
423 GUnicodeScriptMendeKikakuiValue UnicodeScript = 113
424 // Modi. Since: 2.42
425 GUnicodeScriptModiValue UnicodeScript = 114
426 // Mro. Since: 2.42
427 GUnicodeScriptMroValue UnicodeScript = 115
428 // Nabataean. Since: 2.42
429 GUnicodeScriptNabataeanValue UnicodeScript = 116
430 // Old North Arabian. Since: 2.42
431 GUnicodeScriptOldNorthArabianValue UnicodeScript = 117
432 // Old Permic. Since: 2.42
433 GUnicodeScriptOldPermicValue UnicodeScript = 118
434 // Pahawh Hmong. Since: 2.42
435 GUnicodeScriptPahawhHmongValue UnicodeScript = 119
436 // Palmyrene. Since: 2.42
437 GUnicodeScriptPalmyreneValue UnicodeScript = 120
438 // Pau Cin Hau. Since: 2.42
439 GUnicodeScriptPauCinHauValue UnicodeScript = 121
440 // Psalter Pahlavi. Since: 2.42
441 GUnicodeScriptPsalterPahlaviValue UnicodeScript = 122
442 // Siddham. Since: 2.42
443 GUnicodeScriptSiddhamValue UnicodeScript = 123
444 // Tirhuta. Since: 2.42
445 GUnicodeScriptTirhutaValue UnicodeScript = 124
446 // Warang Citi. Since: 2.42
447 GUnicodeScriptWarangCitiValue UnicodeScript = 125
448 // Ahom. Since: 2.48
449 GUnicodeScriptAhomValue UnicodeScript = 126
450 // Anatolian Hieroglyphs. Since: 2.48
451 GUnicodeScriptAnatolianHieroglyphsValue UnicodeScript = 127
452 // Hatran. Since: 2.48
453 GUnicodeScriptHatranValue UnicodeScript = 128
454 // Multani. Since: 2.48
455 GUnicodeScriptMultaniValue UnicodeScript = 129
456 // Old Hungarian. Since: 2.48
457 GUnicodeScriptOldHungarianValue UnicodeScript = 130
458 // Signwriting. Since: 2.48
459 GUnicodeScriptSignwritingValue UnicodeScript = 131
460 // Adlam. Since: 2.50
461 GUnicodeScriptAdlamValue UnicodeScript = 132
462 // Bhaiksuki. Since: 2.50
463 GUnicodeScriptBhaiksukiValue UnicodeScript = 133
464 // Marchen. Since: 2.50
465 GUnicodeScriptMarchenValue UnicodeScript = 134
466 // Newa. Since: 2.50
467 GUnicodeScriptNewaValue UnicodeScript = 135
468 // Osage. Since: 2.50
469 GUnicodeScriptOsageValue UnicodeScript = 136
470 // Tangut. Since: 2.50
471 GUnicodeScriptTangutValue UnicodeScript = 137
472 // Masaram Gondi. Since: 2.54
473 GUnicodeScriptMasaramGondiValue UnicodeScript = 138
474 // Nushu. Since: 2.54
475 GUnicodeScriptNushuValue UnicodeScript = 139
476 // Soyombo. Since: 2.54
477 GUnicodeScriptSoyomboValue UnicodeScript = 140
478 // Zanabazar Square. Since: 2.54
479 GUnicodeScriptZanabazarSquareValue UnicodeScript = 141
480 // Dogra. Since: 2.58
481 GUnicodeScriptDograValue UnicodeScript = 142
482 // Gunjala Gondi. Since: 2.58
483 GUnicodeScriptGunjalaGondiValue UnicodeScript = 143
484 // Hanifi Rohingya. Since: 2.58
485 GUnicodeScriptHanifiRohingyaValue UnicodeScript = 144
486 // Makasar. Since: 2.58
487 GUnicodeScriptMakasarValue UnicodeScript = 145
488 // Medefaidrin. Since: 2.58
489 GUnicodeScriptMedefaidrinValue UnicodeScript = 146
490 // Old Sogdian. Since: 2.58
491 GUnicodeScriptOldSogdianValue UnicodeScript = 147
492 // Sogdian. Since: 2.58
493 GUnicodeScriptSogdianValue UnicodeScript = 148
494 // Elym. Since: 2.62
495 GUnicodeScriptElymaicValue UnicodeScript = 149
496 // Nand. Since: 2.62
497 GUnicodeScriptNandinagariValue UnicodeScript = 150
498 // Rohg. Since: 2.62
499 GUnicodeScriptNyiakengPuachueHmongValue UnicodeScript = 151
500 // Wcho. Since: 2.62
501 GUnicodeScriptWanchoValue UnicodeScript = 152
502 // Chorasmian. Since: 2.66
503 GUnicodeScriptChorasmianValue UnicodeScript = 153
504 // Dives Akuru. Since: 2.66
505 GUnicodeScriptDivesAkuruValue UnicodeScript = 154
506 // Khitan small script. Since: 2.66
507 GUnicodeScriptKhitanSmallScriptValue UnicodeScript = 155
508 // Yezidi. Since: 2.66
509 GUnicodeScriptYezidiValue UnicodeScript = 156
510 // Cypro-Minoan. Since: 2.72
511 GUnicodeScriptCyproMinoanValue UnicodeScript = 157
512 // Old Uyghur. Since: 2.72
513 GUnicodeScriptOldUyghurValue UnicodeScript = 158
514 // Tangsa. Since: 2.72
515 GUnicodeScriptTangsaValue UnicodeScript = 159
516 // Toto. Since: 2.72
517 GUnicodeScriptTotoValue UnicodeScript = 160
518 // Vithkuqi. Since: 2.72
519 GUnicodeScriptVithkuqiValue UnicodeScript = 161
520 // Mathematical notation. Since: 2.72
521 GUnicodeScriptMathValue UnicodeScript = 162
522 // Kawi. Since 2.74
523 GUnicodeScriptKawiValue UnicodeScript = 163
524 // Nag Mundari. Since 2.74
525 GUnicodeScriptNagMundariValue UnicodeScript = 164
526 // Todhri. Since: 2.84
527 GUnicodeScriptTodhriValue UnicodeScript = 165
528 // Garay. Since: 2.84
529 GUnicodeScriptGarayValue UnicodeScript = 166
530 // Tulu-Tigalari. Since: 2.84
531 GUnicodeScriptTuluTigalariValue UnicodeScript = 167
532 // Sunuwar. Since: 2.84
533 GUnicodeScriptSunuwarValue UnicodeScript = 168
534 // Gurung Khema. Since: 2.84
535 GUnicodeScriptGurungKhemaValue UnicodeScript = 169
536 // Kirat Rai. Since: 2.84
537 GUnicodeScriptKiratRaiValue UnicodeScript = 170
538 // Ol Onal. Since: 2.84
539 GUnicodeScriptOlOnalValue UnicodeScript = 171
540)
541
542// These are the possible character classifications from the
543// Unicode specification.
544// See [Unicode Character Database](http://www.unicode.org/reports/tr44/#General_Category_Values).
545type UnicodeType int
546
547var xUnicodeTypeGLibType func() types.GType
548
549func UnicodeTypeGLibType() types.GType {
550 return xUnicodeTypeGLibType()
551}
552
553const (
554
555 // General category "Other, Control" (Cc)
556 GUnicodeControlValue UnicodeType = 0
557 // General category "Other, Format" (Cf)
558 GUnicodeFormatValue UnicodeType = 1
559 // General category "Other, Not Assigned" (Cn)
560 GUnicodeUnassignedValue UnicodeType = 2
561 // General category "Other, Private Use" (Co)
562 GUnicodePrivateUseValue UnicodeType = 3
563 // General category "Other, Surrogate" (Cs)
564 GUnicodeSurrogateValue UnicodeType = 4
565 // General category "Letter, Lowercase" (Ll)
566 GUnicodeLowercaseLetterValue UnicodeType = 5
567 // General category "Letter, Modifier" (Lm)
568 GUnicodeModifierLetterValue UnicodeType = 6
569 // General category "Letter, Other" (Lo)
570 GUnicodeOtherLetterValue UnicodeType = 7
571 // General category "Letter, Titlecase" (Lt)
572 GUnicodeTitlecaseLetterValue UnicodeType = 8
573 // General category "Letter, Uppercase" (Lu)
574 GUnicodeUppercaseLetterValue UnicodeType = 9
575 // General category "Mark, Spacing" (Mc)
576 GUnicodeSpacingMarkValue UnicodeType = 10
577 // General category "Mark, Enclosing" (Me)
578 GUnicodeEnclosingMarkValue UnicodeType = 11
579 // General category "Mark, Nonspacing" (Mn)
580 GUnicodeNonSpacingMarkValue UnicodeType = 12
581 // General category "Number, Decimal Digit" (Nd)
582 GUnicodeDecimalNumberValue UnicodeType = 13
583 // General category "Number, Letter" (Nl)
584 GUnicodeLetterNumberValue UnicodeType = 14
585 // General category "Number, Other" (No)
586 GUnicodeOtherNumberValue UnicodeType = 15
587 // General category "Punctuation, Connector" (Pc)
588 GUnicodeConnectPunctuationValue UnicodeType = 16
589 // General category "Punctuation, Dash" (Pd)
590 GUnicodeDashPunctuationValue UnicodeType = 17
591 // General category "Punctuation, Close" (Pe)
592 GUnicodeClosePunctuationValue UnicodeType = 18
593 // General category "Punctuation, Final quote" (Pf)
594 GUnicodeFinalPunctuationValue UnicodeType = 19
595 // General category "Punctuation, Initial quote" (Pi)
596 GUnicodeInitialPunctuationValue UnicodeType = 20
597 // General category "Punctuation, Other" (Po)
598 GUnicodeOtherPunctuationValue UnicodeType = 21
599 // General category "Punctuation, Open" (Ps)
600 GUnicodeOpenPunctuationValue UnicodeType = 22
601 // General category "Symbol, Currency" (Sc)
602 GUnicodeCurrencySymbolValue UnicodeType = 23
603 // General category "Symbol, Modifier" (Sk)
604 GUnicodeModifierSymbolValue UnicodeType = 24
605 // General category "Symbol, Math" (Sm)
606 GUnicodeMathSymbolValue UnicodeType = 25
607 // General category "Symbol, Other" (So)
608 GUnicodeOtherSymbolValue UnicodeType = 26
609 // General category "Separator, Line" (Zl)
610 GUnicodeLineSeparatorValue UnicodeType = 27
611 // General category "Separator, Paragraph" (Zp)
612 GUnicodeParagraphSeparatorValue UnicodeType = 28
613 // General category "Separator, Space" (Zs)
614 GUnicodeSpaceSeparatorValue UnicodeType = 29
615)
616
617var xUcs4ToUtf16 func([]uint32, int, *int, *int, **Error) uint16
618
619// Convert a string from UCS-4 to UTF-16.
620//
621// A nul character (U+0000) will be added to the result after the converted text.
622func Ucs4ToUtf16(StrVar []uint32, LenVar int, ItemsReadVar *int, ItemsWrittenVar *int) (uint16, error) {
623 var cerr *Error
624
625 cret := xUcs4ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)
626
627 if cerr == nil {
628 return cret, nil
629 }
630 return cret, cerr
631
632}
633
634var xUcs4ToUtf8 func([]uint32, int, *int, *int, **Error) string
635
636// Convert a string from a 32-bit fixed width representation as UCS-4.
637// to UTF-8.
638//
639// The result will be terminated with a nul byte.
640func Ucs4ToUtf8(StrVar []uint32, LenVar int, ItemsReadVar *int, ItemsWrittenVar *int) (string, error) {
641 var cerr *Error
642
643 cret := xUcs4ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)
644
645 if cerr == nil {
646 return cret, nil
647 }
648 return cret, cerr
649
650}
651
652var xUnicharBreakType func(uint32) UnicodeBreakType
653
654// Determines the break type of @c. @c should be a Unicode character
655// (to derive a character from UTF-8 encoded text, use
656// g_utf8_get_char()). The break type is used to find word and line
657// breaks ("text boundaries"), Pango implements the Unicode boundary
658// resolution algorithms and normally you would use a function such
659// as pango_break() instead of caring about break types yourself.
660func UnicharBreakType(CVar uint32) UnicodeBreakType {
661
662 cret := xUnicharBreakType(CVar)
663
664 return cret
665}
666
667var xUnicharCombiningClass func(uint32) int
668
669// Determines the canonical combining class of a Unicode character.
670func UnicharCombiningClass(UcVar uint32) int {
671
672 cret := xUnicharCombiningClass(UcVar)
673
674 return cret
675}
676
677var xUnicharCompose func(uint32, uint32, *uint32) bool
678
679// Performs a single composition step of the
680// Unicode canonical composition algorithm.
681//
682// This function includes algorithmic Hangul Jamo composition,
683// but it is not exactly the inverse of g_unichar_decompose().
684// No composition can have either of @a or @b equal to zero.
685// To be precise, this function composes if and only if
686// there exists a Primary Composite P which is canonically
687// equivalent to the sequence <@a,@b>. See the Unicode
688// Standard for the definition of Primary Composite.
689//
690// If @a and @b do not compose a new character, @ch is set to zero.
691//
692// See
693// [UAX#15](http://unicode.org/reports/tr15/)
694// for details.
695func UnicharCompose(AVar uint32, BVar uint32, ChVar *uint32) bool {
696
697 cret := xUnicharCompose(AVar, BVar, ChVar)
698
699 return cret
700}
701
702var xUnicharDecompose func(uint32, *uint32, *uint32) bool
703
704// Performs a single decomposition step of the
705// Unicode canonical decomposition algorithm.
706//
707// This function does not include compatibility
708// decompositions. It does, however, include algorithmic
709// Hangul Jamo decomposition, as well as 'singleton'
710// decompositions which replace a character by a single
711// other character. In the case of singletons `*b` will
712// be set to zero.
713//
714// If @ch is not decomposable, `*a` is set to @ch and `*b`
715// is set to zero.
716//
717// Note that the way Unicode decomposition pairs are
718// defined, it is guaranteed that @b would not decompose
719// further, but @a may itself decompose. To get the full
720// canonical decomposition for @ch, one would need to
721// recursively call this function on @a. Or use
722// g_unichar_fully_decompose().
723//
724// See
725// [UAX#15](http://unicode.org/reports/tr15/)
726// for details.
727func UnicharDecompose(ChVar uint32, AVar *uint32, BVar *uint32) bool {
728
729 cret := xUnicharDecompose(ChVar, AVar, BVar)
730
731 return cret
732}
733
734var xUnicharDigitValue func(uint32) int
735
736// Determines the numeric value of a character as a decimal
737// digit.
738func UnicharDigitValue(CVar uint32) int {
739
740 cret := xUnicharDigitValue(CVar)
741
742 return cret
743}
744
745var xUnicharFullyDecompose func(uint32, bool, *uint32, uint) uint
746
747// Computes the canonical or compatibility decomposition of a
748// Unicode character. For compatibility decomposition,
749// pass %TRUE for @compat; for canonical decomposition
750// pass %FALSE for @compat.
751//
752// The decomposed sequence is placed in @result. Only up to
753// @result_len characters are written into @result. The length
754// of the full decomposition (irrespective of @result_len) is
755// returned by the function. For canonical decomposition,
756// currently all decompositions are of length at most 4, but
757// this may change in the future (very unlikely though).
758// At any rate, Unicode does guarantee that a buffer of length
759// 18 is always enough for both compatibility and canonical
760// decompositions, so that is the size recommended. This is provided
761// as %G_UNICHAR_MAX_DECOMPOSITION_LENGTH.
762//
763// See
764// [UAX#15](http://unicode.org/reports/tr15/)
765// for details.
766func UnicharFullyDecompose(ChVar uint32, CompatVar bool, ResultVar *uint32, ResultLenVar uint) uint {
767
768 cret := xUnicharFullyDecompose(ChVar, CompatVar, ResultVar, ResultLenVar)
769
770 return cret
771}
772
773var xUnicharGetMirrorChar func(uint32, *uint32) bool
774
775// In Unicode, some characters are "mirrored". This means that their
776// images are mirrored horizontally in text that is laid out from right
777// to left. For instance, "(" would become its mirror image, ")", in
778// right-to-left text.
779//
780// If @ch has the Unicode mirrored property and there is another unicode
781// character that typically has a glyph that is the mirror image of @ch's
782// glyph and @mirrored_ch is set, it puts that character in the address
783// pointed to by @mirrored_ch. Otherwise the original character is put.
784func UnicharGetMirrorChar(ChVar uint32, MirroredChVar *uint32) bool {
785
786 cret := xUnicharGetMirrorChar(ChVar, MirroredChVar)
787
788 return cret
789}
790
791var xUnicharGetScript func(uint32) UnicodeScript
792
793// Looks up the #GUnicodeScript for a particular character (as defined
794// by Unicode Standard Annex \#24). No check is made for @ch being a
795// valid Unicode character; if you pass in invalid character, the
796// result is undefined.
797//
798// This function is equivalent to pango_script_for_unichar() and the
799// two are interchangeable.
800func UnicharGetScript(ChVar uint32) UnicodeScript {
801
802 cret := xUnicharGetScript(ChVar)
803
804 return cret
805}
806
807var xUnicharIsalnum func(uint32) bool
808
809// Determines whether a character is alphanumeric.
810// Given some UTF-8 text, obtain a character value
811// with g_utf8_get_char().
812func UnicharIsalnum(CVar uint32) bool {
813
814 cret := xUnicharIsalnum(CVar)
815
816 return cret
817}
818
819var xUnicharIsalpha func(uint32) bool
820
821// Determines whether a character is alphabetic (i.e. a letter).
822// Given some UTF-8 text, obtain a character value with
823// g_utf8_get_char().
824func UnicharIsalpha(CVar uint32) bool {
825
826 cret := xUnicharIsalpha(CVar)
827
828 return cret
829}
830
831var xUnicharIscntrl func(uint32) bool
832
833// Determines whether a character is a control character.
834// Given some UTF-8 text, obtain a character value with
835// g_utf8_get_char().
836func UnicharIscntrl(CVar uint32) bool {
837
838 cret := xUnicharIscntrl(CVar)
839
840 return cret
841}
842
843var xUnicharIsdefined func(uint32) bool
844
845// Determines if a given character is assigned in the Unicode
846// standard.
847func UnicharIsdefined(CVar uint32) bool {
848
849 cret := xUnicharIsdefined(CVar)
850
851 return cret
852}
853
854var xUnicharIsdigit func(uint32) bool
855
856// Determines whether a character is numeric (i.e. a digit). This
857// covers ASCII 0-9 and also digits in other languages/scripts. Given
858// some UTF-8 text, obtain a character value with g_utf8_get_char().
859func UnicharIsdigit(CVar uint32) bool {
860
861 cret := xUnicharIsdigit(CVar)
862
863 return cret
864}
865
866var xUnicharIsgraph func(uint32) bool
867
868// Determines whether a character is printable and not a space
869// (returns %FALSE for control characters, format characters, and
870// spaces). g_unichar_isprint() is similar, but returns %TRUE for
871// spaces. Given some UTF-8 text, obtain a character value with
872// g_utf8_get_char().
873func UnicharIsgraph(CVar uint32) bool {
874
875 cret := xUnicharIsgraph(CVar)
876
877 return cret
878}
879
880var xUnicharIslower func(uint32) bool
881
882// Determines whether a character is a lowercase letter.
883// Given some UTF-8 text, obtain a character value with
884// g_utf8_get_char().
885func UnicharIslower(CVar uint32) bool {
886
887 cret := xUnicharIslower(CVar)
888
889 return cret
890}
891
892var xUnicharIsmark func(uint32) bool
893
894// Determines whether a character is a mark (non-spacing mark,
895// combining mark, or enclosing mark in Unicode speak).
896// Given some UTF-8 text, obtain a character value
897// with g_utf8_get_char().
898//
899// Note: in most cases where isalpha characters are allowed,
900// ismark characters should be allowed to as they are essential
901// for writing most European languages as well as many non-Latin
902// scripts.
903func UnicharIsmark(CVar uint32) bool {
904
905 cret := xUnicharIsmark(CVar)
906
907 return cret
908}
909
910var xUnicharIsprint func(uint32) bool
911
912// Determines whether a character is printable.
913// Unlike g_unichar_isgraph(), returns %TRUE for spaces.
914// Given some UTF-8 text, obtain a character value with
915// g_utf8_get_char().
916func UnicharIsprint(CVar uint32) bool {
917
918 cret := xUnicharIsprint(CVar)
919
920 return cret
921}
922
923var xUnicharIspunct func(uint32) bool
924
925// Determines whether a character is punctuation or a symbol.
926// Given some UTF-8 text, obtain a character value with
927// g_utf8_get_char().
928func UnicharIspunct(CVar uint32) bool {
929
930 cret := xUnicharIspunct(CVar)
931
932 return cret
933}
934
935var xUnicharIsspace func(uint32) bool
936
937// Determines whether a character is a space, tab, or line separator
938// (newline, carriage return, etc.). Given some UTF-8 text, obtain a
939// character value with g_utf8_get_char().
940//
941// (Note: don't use this to do word breaking; you have to use
942// Pango or equivalent to get word breaking right, the algorithm
943// is fairly complex.)
944func UnicharIsspace(CVar uint32) bool {
945
946 cret := xUnicharIsspace(CVar)
947
948 return cret
949}
950
951var xUnicharIstitle func(uint32) bool
952
953// Determines if a character is titlecase. Some characters in
954// Unicode which are composites, such as the DZ digraph
955// have three case variants instead of just two. The titlecase
956// form is used at the beginning of a word where only the
957// first letter is capitalized. The titlecase form of the DZ
958// digraph is U+01F2 LATIN CAPITAL LETTTER D WITH SMALL LETTER Z.
959func UnicharIstitle(CVar uint32) bool {
960
961 cret := xUnicharIstitle(CVar)
962
963 return cret
964}
965
966var xUnicharIsupper func(uint32) bool
967
968// Determines if a character is uppercase.
969func UnicharIsupper(CVar uint32) bool {
970
971 cret := xUnicharIsupper(CVar)
972
973 return cret
974}
975
976var xUnicharIswide func(uint32) bool
977
978// Determines if a character is typically rendered in a double-width
979// cell.
980func UnicharIswide(CVar uint32) bool {
981
982 cret := xUnicharIswide(CVar)
983
984 return cret
985}
986
987var xUnicharIswideCjk func(uint32) bool
988
989// Determines if a character is typically rendered in a double-width
990// cell under legacy East Asian locales. If a character is wide according to
991// g_unichar_iswide(), then it is also reported wide with this function, but
992// the converse is not necessarily true. See the
993// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
994// for details.
995//
996// If a character passes the g_unichar_iswide() test then it will also pass
997// this test, but not the other way around. Note that some characters may
998// pass both this test and g_unichar_iszerowidth().
999func UnicharIswideCjk(CVar uint32) bool {
1000
1001 cret := xUnicharIswideCjk(CVar)
1002
1003 return cret
1004}
1005
1006var xUnicharIsxdigit func(uint32) bool
1007
1008// Determines if a character is a hexadecimal digit.
1009func UnicharIsxdigit(CVar uint32) bool {
1010
1011 cret := xUnicharIsxdigit(CVar)
1012
1013 return cret
1014}
1015
1016var xUnicharIszerowidth func(uint32) bool
1017
1018// Determines if a given character typically takes zero width when rendered.
1019// The return value is %TRUE for all non-spacing and enclosing marks
1020// (e.g., combining accents), format characters, zero-width
1021// space, but not U+00AD SOFT HYPHEN.
1022//
1023// A typical use of this function is with one of g_unichar_iswide() or
1024// g_unichar_iswide_cjk() to determine the number of cells a string occupies
1025// when displayed on a grid display (terminals). However, note that not all
1026// terminals support zero-width rendering of zero-width marks.
1027func UnicharIszerowidth(CVar uint32) bool {
1028
1029 cret := xUnicharIszerowidth(CVar)
1030
1031 return cret
1032}
1033
1034var xUnicharToUtf8 func(uint32, *string) int
1035
1036// Converts a single character to UTF-8.
1037func UnicharToUtf8(CVar uint32, OutbufVar *string) int {
1038
1039 cret := xUnicharToUtf8(CVar, OutbufVar)
1040
1041 return cret
1042}
1043
1044var xUnicharTolower func(uint32) uint32
1045
1046// Converts a character to lower case.
1047func UnicharTolower(CVar uint32) uint32 {
1048
1049 cret := xUnicharTolower(CVar)
1050
1051 return cret
1052}
1053
1054var xUnicharTotitle func(uint32) uint32
1055
1056// Converts a character to the titlecase.
1057func UnicharTotitle(CVar uint32) uint32 {
1058
1059 cret := xUnicharTotitle(CVar)
1060
1061 return cret
1062}
1063
1064var xUnicharToupper func(uint32) uint32
1065
1066// Converts a character to uppercase.
1067func UnicharToupper(CVar uint32) uint32 {
1068
1069 cret := xUnicharToupper(CVar)
1070
1071 return cret
1072}
1073
1074var xUnicharType func(uint32) UnicodeType
1075
1076// Classifies a Unicode character by type.
1077func UnicharType(CVar uint32) UnicodeType {
1078
1079 cret := xUnicharType(CVar)
1080
1081 return cret
1082}
1083
1084var xUnicharValidate func(uint32) bool
1085
1086// Checks whether @ch is a valid Unicode character.
1087//
1088// Some possible integer values of @ch will not be valid. U+0000 is considered a
1089// valid character, though it’s normally a string terminator.
1090func UnicharValidate(ChVar uint32) bool {
1091
1092 cret := xUnicharValidate(ChVar)
1093
1094 return cret
1095}
1096
1097var xUnicharXdigitValue func(uint32) int
1098
1099// Determines the numeric value of a character as a hexadecimal
1100// digit.
1101func UnicharXdigitValue(CVar uint32) int {
1102
1103 cret := xUnicharXdigitValue(CVar)
1104
1105 return cret
1106}
1107
1108var xUnicodeCanonicalDecomposition func(uint32, uint) uint32
1109
1110// Computes the canonical decomposition of a Unicode character.
1111func UnicodeCanonicalDecomposition(ChVar uint32, ResultLenVar uint) uint32 {
1112
1113 cret := xUnicodeCanonicalDecomposition(ChVar, ResultLenVar)
1114
1115 return cret
1116}
1117
1118var xUnicodeCanonicalOrdering func([]uint32, uint)
1119
1120// Computes the canonical ordering of a string in-place.
1121// This rearranges decomposed characters in the string
1122// according to their combining classes. See the Unicode
1123// manual for more information.
1124func UnicodeCanonicalOrdering(StringVar []uint32, LenVar uint) {
1125
1126 xUnicodeCanonicalOrdering(StringVar, LenVar)
1127
1128}
1129
1130var xUnicodeScriptFromIso15924 func(uint32) UnicodeScript
1131
1132// Looks up the Unicode script for @iso15924. ISO 15924 assigns four-letter
1133// codes to scripts. For example, the code for Arabic is 'Arab'.
1134// This function accepts four letter codes encoded as a @guint32 in a
1135// big-endian fashion. That is, the code expected for Arabic is
1136// 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc).
1137//
1138// See
1139// [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html)
1140// for details.
1141func UnicodeScriptFromIso15924(Iso15924Var uint32) UnicodeScript {
1142
1143 cret := xUnicodeScriptFromIso15924(Iso15924Var)
1144
1145 return cret
1146}
1147
1148var xUnicodeScriptToIso15924 func(UnicodeScript) uint32
1149
1150// Looks up the ISO 15924 code for @script. ISO 15924 assigns four-letter
1151// codes to scripts. For example, the code for Arabic is 'Arab'. The
1152// four letter codes are encoded as a @guint32 by this function in a
1153// big-endian fashion. That is, the code returned for Arabic is
1154// 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc).
1155//
1156// See
1157// [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html)
1158// for details.
1159func UnicodeScriptToIso15924(ScriptVar UnicodeScript) uint32 {
1160
1161 cret := xUnicodeScriptToIso15924(ScriptVar)
1162
1163 return cret
1164}
1165
1166var xUtf16ToUcs4 func([]uint16, int, *int, *int, **Error) uint32
1167
1168// Convert a string from UTF-16 to UCS-4.
1169//
1170// The result will be nul-terminated.
1171func Utf16ToUcs4(StrVar []uint16, LenVar int, ItemsReadVar *int, ItemsWrittenVar *int) (uint32, error) {
1172 var cerr *Error
1173
1174 cret := xUtf16ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)
1175
1176 if cerr == nil {
1177 return cret, nil
1178 }
1179 return cret, cerr
1180
1181}
1182
1183var xUtf16ToUtf8 func([]uint16, int, *int, *int, **Error) string
1184
1185// Convert a string from UTF-16 to UTF-8.
1186//
1187// The result will be terminated with a nul byte.
1188//
1189// Note that the input is expected to be already in native endianness,
1190// an initial byte-order-mark character is not handled specially.
1191// [func@GLib.convert] can be used to convert a byte buffer of UTF-16 data of
1192// ambiguous endianness.
1193//
1194// Further note that this function does not validate the result
1195// string; it may (for example) include embedded nul characters. The only
1196// validation done by this function is to ensure that the input can
1197// be correctly interpreted as UTF-16, i.e. it doesn’t contain
1198// unpaired surrogates or partial character sequences.
1199func Utf16ToUtf8(StrVar []uint16, LenVar int, ItemsReadVar *int, ItemsWrittenVar *int) (string, error) {
1200 var cerr *Error
1201
1202 cret := xUtf16ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)
1203
1204 if cerr == nil {
1205 return cret, nil
1206 }
1207 return cret, cerr
1208
1209}
1210
1211var xUtf8Casefold func(string, int) string
1212
1213// Converts a string into a form that is independent of case. The
1214// result will not correspond to any particular case, but can be
1215// compared for equality or ordered with the results of calling
1216// g_utf8_casefold() on other strings.
1217//
1218// Note that calling g_utf8_casefold() followed by g_utf8_collate() is
1219// only an approximation to the correct linguistic case insensitive
1220// ordering, though it is a fairly good one. Getting this exactly
1221// right would require a more sophisticated collation function that
1222// takes case sensitivity into account. GLib does not currently
1223// provide such a function.
1224func Utf8Casefold(StrVar string, LenVar int) string {
1225
1226 cret := xUtf8Casefold(StrVar, LenVar)
1227
1228 return cret
1229}
1230
1231var xUtf8Collate func(string, string) int
1232
1233// Compares two strings for ordering using the linguistically
1234// correct rules for the [current locale](running.html#locale).
1235// When sorting a large number of strings, it will be significantly
1236// faster to obtain collation keys with g_utf8_collate_key() and
1237// compare the keys with strcmp() when sorting instead of sorting
1238// the original strings.
1239//
1240// If the two strings are not comparable due to being in different collation
1241// sequences, the result is undefined. This can happen if the strings are in
1242// different language scripts, for example.
1243func Utf8Collate(Str1Var string, Str2Var string) int {
1244
1245 cret := xUtf8Collate(Str1Var, Str2Var)
1246
1247 return cret
1248}
1249
1250var xUtf8CollateKey func(string, int) string
1251
1252// Converts a string into a collation key that can be compared
1253// with other collation keys produced by the same function using
1254// strcmp().
1255//
1256// The results of comparing the collation keys of two strings
1257// with strcmp() will always be the same as comparing the two
1258// original keys with g_utf8_collate().
1259//
1260// Note that this function depends on the [current locale](running.html#locale).
1261//
1262// Note that the returned string is not guaranteed to be in any
1263// encoding, especially UTF-8. The returned value is meant to be
1264// used only for comparisons.
1265func Utf8CollateKey(StrVar string, LenVar int) string {
1266
1267 cret := xUtf8CollateKey(StrVar, LenVar)
1268
1269 return cret
1270}
1271
1272var xUtf8CollateKeyForFilename func(string, int) string
1273
1274// Converts a string into a collation key that can be compared
1275// with other collation keys produced by the same function using strcmp().
1276//
1277// In order to sort filenames correctly, this function treats the dot '.'
1278// as a special case. Most dictionary orderings seem to consider it
1279// insignificant, thus producing the ordering "event.c" "eventgenerator.c"
1280// "event.h" instead of "event.c" "event.h" "eventgenerator.c". Also, we
1281// would like to treat numbers intelligently so that "file1" "file10" "file5"
1282// is sorted as "file1" "file5" "file10".
1283//
1284// Note that this function depends on the [current locale](running.html#locale).
1285//
1286// Note that the returned string is not guaranteed to be in any
1287// encoding, especially UTF-8. The returned value is meant to be
1288// used only for comparisons.
1289func Utf8CollateKeyForFilename(StrVar string, LenVar int) string {
1290
1291 cret := xUtf8CollateKeyForFilename(StrVar, LenVar)
1292
1293 return cret
1294}
1295
1296var xUtf8FindNextChar func(string, uintptr) string
1297
1298// Finds the start of the next UTF-8 character in the string after @p.
1299//
1300// @p does not have to be at the beginning of a UTF-8 character. No check
1301// is made to see if the character found is actually valid other than
1302// it starts with an appropriate byte.
1303//
1304// If @end is `NULL`, the return value will never be `NULL`: if the end of the
1305// string is reached, a pointer to the terminating nul byte is returned. If
1306// @end is non-`NULL`, the return value will be `NULL` if the end of the string
1307// is reached.
1308func Utf8FindNextChar(PVar string, EndVar *string) string {
1309
1310 EndVarPtr := core.GStrdupNullable(EndVar)
1311 defer core.GFreeNullable(EndVarPtr)
1312
1313 cret := xUtf8FindNextChar(PVar, EndVarPtr)
1314
1315 return cret
1316}
1317
1318var xUtf8FindPrevChar func(string, string) string
1319
1320// Given a position @p with a UTF-8 encoded string @str, find the start
1321// of the previous UTF-8 character starting before @p. Returns `NULL` if no
1322// UTF-8 characters are present in @str before @p.
1323//
1324// @p does not have to be at the beginning of a UTF-8 character. No check
1325// is made to see if the character found is actually valid other than
1326// it starts with an appropriate byte.
1327func Utf8FindPrevChar(StrVar string, PVar string) string {
1328
1329 cret := xUtf8FindPrevChar(StrVar, PVar)
1330
1331 return cret
1332}
1333
1334var xUtf8GetChar func(string) uint32
1335
1336// Converts a sequence of bytes encoded as UTF-8 to a Unicode character.
1337//
1338// If @p does not point to a valid UTF-8 encoded character, results
1339// are undefined. If you are not sure that the bytes are complete
1340// valid Unicode characters, you should use [func@GLib.utf8_get_char_validated]
1341// instead.
1342func Utf8GetChar(PVar string) uint32 {
1343
1344 cret := xUtf8GetChar(PVar)
1345
1346 return cret
1347}
1348
1349var xUtf8GetCharValidated func(string, int) uint32
1350
1351// Convert a sequence of bytes encoded as UTF-8 to a Unicode character.
1352//
1353// This function checks for incomplete characters, for invalid characters
1354// such as characters that are out of the range of Unicode, and for
1355// overlong encodings of valid characters.
1356//
1357// Note that [func@GLib.utf8_get_char_validated] returns `(gunichar)-2` if
1358// @max_len is positive and any of the bytes in the first UTF-8 character
1359// sequence are nul.
1360func Utf8GetCharValidated(PVar string, MaxLenVar int) uint32 {
1361
1362 cret := xUtf8GetCharValidated(PVar, MaxLenVar)
1363
1364 return cret
1365}
1366
1367var xUtf8MakeValid func(string, int) string
1368
1369// If the provided string is valid UTF-8, return a copy of it. If not,
1370// return a copy in which bytes that could not be interpreted as valid Unicode
1371// are replaced with the Unicode replacement character (U+FFFD).
1372//
1373// For example, this is an appropriate function to use if you have received
1374// a string that was incorrectly declared to be UTF-8, and you need a valid
1375// UTF-8 version of it that can be logged or displayed to the user, with the
1376// assumption that it is close enough to ASCII or UTF-8 to be mostly
1377// readable as-is.
1378func Utf8MakeValid(StrVar string, LenVar int) string {
1379
1380 cret := xUtf8MakeValid(StrVar, LenVar)
1381
1382 return cret
1383}
1384
1385var xUtf8Normalize func(string, int, NormalizeMode) string
1386
1387// Converts a string into canonical form, standardizing
1388// such issues as whether a character with an accent
1389// is represented as a base character and combining
1390// accent or as a single precomposed character. The
1391// string has to be valid UTF-8, otherwise %NULL is
1392// returned. You should generally call g_utf8_normalize()
1393// before comparing two Unicode strings.
1394//
1395// The normalization mode %G_NORMALIZE_DEFAULT only
1396// standardizes differences that do not affect the
1397// text content, such as the above-mentioned accent
1398// representation. %G_NORMALIZE_ALL also standardizes
1399// the "compatibility" characters in Unicode, such
1400// as SUPERSCRIPT THREE to the standard forms
1401// (in this case DIGIT THREE). Formatting information
1402// may be lost but for most text operations such
1403// characters should be considered the same.
1404//
1405// %G_NORMALIZE_DEFAULT_COMPOSE and %G_NORMALIZE_ALL_COMPOSE
1406// are like %G_NORMALIZE_DEFAULT and %G_NORMALIZE_ALL,
1407// but returned a result with composed forms rather
1408// than a maximally decomposed form. This is often
1409// useful if you intend to convert the string to
1410// a legacy encoding or pass it to a system with
1411// less capable Unicode handling.
1412func Utf8Normalize(StrVar string, LenVar int, ModeVar NormalizeMode) string {
1413
1414 cret := xUtf8Normalize(StrVar, LenVar, ModeVar)
1415
1416 return cret
1417}
1418
1419var xUtf8OffsetToPointer func(string, int) string
1420
1421// Converts from an integer character offset to a pointer to a position
1422// within the string.
1423//
1424// Since 2.10, this function allows to pass a negative @offset to
1425// step backwards. It is usually worth stepping backwards from the end
1426// instead of forwards if @offset is in the last fourth of the string,
1427// since moving forward is about 3 times faster than moving backward.
1428//
1429// Note that this function doesn’t abort when reaching the end of @str.
1430// Therefore you should be sure that @offset is within string boundaries
1431// before calling that function. Call [func@GLib.utf8_strlen] when unsure.
1432// This limitation exists as this function is called frequently during
1433// text rendering and therefore has to be as fast as possible.
1434func Utf8OffsetToPointer(StrVar string, OffsetVar int) string {
1435
1436 cret := xUtf8OffsetToPointer(StrVar, OffsetVar)
1437
1438 return cret
1439}
1440
1441var xUtf8PointerToOffset func(string, string) int
1442
1443// Converts from a pointer to position within a string to an integer
1444// character offset.
1445//
1446// Since 2.10, this function allows @pos to be before @str, and returns
1447// a negative offset in this case.
1448func Utf8PointerToOffset(StrVar string, PosVar string) int {
1449
1450 cret := xUtf8PointerToOffset(StrVar, PosVar)
1451
1452 return cret
1453}
1454
1455var xUtf8PrevChar func(string) string
1456
1457// Finds the previous UTF-8 character in the string before @p.
1458//
1459// @p does not have to be at the beginning of a UTF-8 character. No check
1460// is made to see if the character found is actually valid other than
1461// it starts with an appropriate byte. If @p might be the first
1462// character of the string, you must use [func@GLib.utf8_find_prev_char]
1463// instead.
1464func Utf8PrevChar(PVar string) string {
1465
1466 cret := xUtf8PrevChar(PVar)
1467
1468 return cret
1469}
1470
1471var xUtf8Strchr func(string, int, uint32) string
1472
1473// Finds the leftmost occurrence of the given Unicode character
1474// in a UTF-8 encoded string, while limiting the search to @len bytes.
1475//
1476// If @len is `-1`, allow unbounded search.
1477func Utf8Strchr(PVar string, LenVar int, CVar uint32) string {
1478
1479 cret := xUtf8Strchr(PVar, LenVar, CVar)
1480
1481 return cret
1482}
1483
1484var xUtf8Strdown func(string, int) string
1485
1486// Converts all Unicode characters in the string that have a case
1487// to lowercase. The exact manner that this is done depends
1488// on the current locale, and may result in the number of
1489// characters in the string changing.
1490func Utf8Strdown(StrVar string, LenVar int) string {
1491
1492 cret := xUtf8Strdown(StrVar, LenVar)
1493
1494 return cret
1495}
1496
1497var xUtf8Strlen func(string, int) int
1498
1499// Computes the length of the string in characters, not including
1500// the terminating nul character. If the @max’th byte falls in the
1501// middle of a character, the last (partial) character is not counted.
1502func Utf8Strlen(PVar string, MaxVar int) int {
1503
1504 cret := xUtf8Strlen(PVar, MaxVar)
1505
1506 return cret
1507}
1508
1509var xUtf8Strncpy func(string, string, uint) string
1510
1511// Like the standard C [`strncpy()`](man:strncpy) function, but copies a given
1512// number of characters instead of a given number of bytes.
1513//
1514// The @src string must be valid UTF-8 encoded text. (Use
1515// [func@GLib.utf8_validate] on all text before trying to use UTF-8 utility
1516// functions with it.)
1517//
1518// Note you must ensure @dest is at least 4 * @n + 1 to fit the
1519// largest possible UTF-8 characters
1520func Utf8Strncpy(DestVar string, SrcVar string, NVar uint) string {
1521
1522 cret := xUtf8Strncpy(DestVar, SrcVar, NVar)
1523
1524 return cret
1525}
1526
1527var xUtf8Strrchr func(string, int, uint32) string
1528
1529// Find the rightmost occurrence of the given Unicode character
1530// in a UTF-8 encoded string, while limiting the search to @len bytes.
1531//
1532// If @len is `-1`, allow unbounded search.
1533func Utf8Strrchr(PVar string, LenVar int, CVar uint32) string {
1534
1535 cret := xUtf8Strrchr(PVar, LenVar, CVar)
1536
1537 return cret
1538}
1539
1540var xUtf8Strreverse func(string, int) string
1541
1542// Reverses a UTF-8 string.
1543//
1544// @str must be valid UTF-8 encoded text. (Use [func@GLib.utf8_validate] on all
1545// text before trying to use UTF-8 utility functions with it.)
1546//
1547// This function is intended for programmatic uses of reversed strings.
1548// It pays no attention to decomposed characters, combining marks, byte
1549// order marks, directional indicators (LRM, LRO, etc) and similar
1550// characters which might need special handling when reversing a string
1551// for display purposes.
1552//
1553// Note that unlike [func@GLib.strreverse], this function returns
1554// newly-allocated memory, which should be freed with [func@GLib.free] when
1555// no longer needed.
1556func Utf8Strreverse(StrVar string, LenVar int) string {
1557
1558 cret := xUtf8Strreverse(StrVar, LenVar)
1559
1560 return cret
1561}
1562
1563var xUtf8Strup func(string, int) string
1564
1565// Converts all Unicode characters in the string that have a case
1566// to uppercase. The exact manner that this is done depends
1567// on the current locale, and may result in the number of
1568// characters in the string increasing. (For instance, the
1569// German ess-zet will be changed to SS.)
1570func Utf8Strup(StrVar string, LenVar int) string {
1571
1572 cret := xUtf8Strup(StrVar, LenVar)
1573
1574 return cret
1575}
1576
1577var xUtf8Substring func(string, int, int) string
1578
1579// Copies a substring out of a UTF-8 encoded string.
1580// The substring will contain @end_pos - @start_pos characters.
1581//
1582// Since GLib 2.72, `-1` can be passed to @end_pos to indicate the
1583// end of the string.
1584func Utf8Substring(StrVar string, StartPosVar int, EndPosVar int) string {
1585
1586 cret := xUtf8Substring(StrVar, StartPosVar, EndPosVar)
1587
1588 return cret
1589}
1590
1591var xUtf8ToUcs4 func(string, int, *int, *int, **Error) uint32
1592
1593// Convert a string from UTF-8 to a 32-bit fixed width representation as UCS-4.
1594//
1595// A trailing nul character (U+0000) will be added to the string after the
1596// converted text.
1597func Utf8ToUcs4(StrVar string, LenVar int, ItemsReadVar *int, ItemsWrittenVar *int) (uint32, error) {
1598 var cerr *Error
1599
1600 cret := xUtf8ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)
1601
1602 if cerr == nil {
1603 return cret, nil
1604 }
1605 return cret, cerr
1606
1607}
1608
1609var xUtf8ToUcs4Fast func(string, int, *int) uint32
1610
1611// Convert a string from UTF-8 to a 32-bit fixed width
1612// representation as UCS-4, assuming valid UTF-8 input.
1613//
1614// This function is roughly twice as fast as [func@GLib.utf8_to_ucs4]
1615// but does no error checking on the input. A trailing nul character (U+0000)
1616// will be added to the string after the converted text.
1617func Utf8ToUcs4Fast(StrVar string, LenVar int, ItemsWrittenVar *int) uint32 {
1618
1619 cret := xUtf8ToUcs4Fast(StrVar, LenVar, ItemsWrittenVar)
1620
1621 return cret
1622}
1623
1624var xUtf8ToUtf16 func(string, int, *int, *int, **Error) uint16
1625
1626// Convert a string from UTF-8 to UTF-16.
1627//
1628// A nul character (U+0000) will be added to the result after the converted text.
1629func Utf8ToUtf16(StrVar string, LenVar int, ItemsReadVar *int, ItemsWrittenVar *int) (uint16, error) {
1630 var cerr *Error
1631
1632 cret := xUtf8ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)
1633
1634 if cerr == nil {
1635 return cret, nil
1636 }
1637 return cret, cerr
1638
1639}
1640
1641var xUtf8TruncateMiddle func(string, uint) string
1642
1643// Cuts off the middle of the string, preserving half of @truncate_length
1644// characters at the beginning and half at the end.
1645//
1646// If @string is already short enough, this returns a copy of @string.
1647// If @truncate_length is `0`, an empty string is returned.
1648func Utf8TruncateMiddle(StringVar string, TruncateLengthVar uint) string {
1649
1650 cret := xUtf8TruncateMiddle(StringVar, TruncateLengthVar)
1651
1652 return cret
1653}
1654
1655var xUtf8Validate func([]byte, int, *[]byte) bool
1656
1657// Validates UTF-8 encoded text.
1658//
1659// @str is the text to validate; if @str is nul-terminated, then @max_len can be
1660// `-1`, otherwise @max_len should be the number of bytes to validate.
1661//
1662// If @end is non-`NULL`, then the end of the valid range will be stored there.
1663// This is the first byte of the first invalid character if some bytes were
1664// invalid, or the end of the text being validated otherwise — either the
1665// trailing nul byte, or the first byte beyond @max_len (if it’s positive).
1666//
1667// Note that `g_utf8_validate()` returns `FALSE` if @max_len is positive and
1668// any of the @max_len bytes are nul.
1669//
1670// Returns `TRUE` if all of @str was valid. Many GLib and GTK
1671// routines require valid UTF-8 as input; so data read from a file
1672// or the network should be checked with `g_utf8_validate()` before
1673// doing anything else with it.
1674func Utf8Validate(StrVar []byte, MaxLenVar int, EndVar *[]byte) bool {
1675
1676 cret := xUtf8Validate(StrVar, MaxLenVar, EndVar)
1677
1678 return cret
1679}
1680
1681var xUtf8ValidateLen func([]byte, uint, *[]byte) bool
1682
1683// Validates UTF-8 encoded text.
1684//
1685// As with [func@GLib.utf8_validate], but @max_len must be set, and hence this
1686// function will always return `FALSE` if any of the bytes of @str are nul.
1687func Utf8ValidateLen(StrVar []byte, MaxLenVar uint, EndVar *[]byte) bool {
1688
1689 cret := xUtf8ValidateLen(StrVar, MaxLenVar, EndVar)
1690
1691 return cret
1692}
1693
1694func init() {
1695 core.SetPackageName("GLIB", "glib-2.0")
1696 core.SetSharedLibraries("GLIB", []string{"libgobject-2.0.so.0", "libglib-2.0.so.0"})
1697 var libs []uintptr
1698 for _, libPath := range core.GetPaths("GLIB") {
1699 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
1700 if err != nil {
1701 panic(err)
1702 }
1703 libs = append(libs, lib)
1704 }
1705
1706 core.PuregoSafeRegister(&xNormalizeModeGLibType, libs, "g_normalize_mode_get_type")
1707
1708 core.PuregoSafeRegister(&xUnicodeBreakTypeGLibType, libs, "g_unicode_break_type_get_type")
1709
1710 core.PuregoSafeRegister(&xUnicodeScriptGLibType, libs, "g_unicode_script_get_type")
1711
1712 core.PuregoSafeRegister(&xUnicodeTypeGLibType, libs, "g_unicode_type_get_type")
1713
1714 core.PuregoSafeRegister(&xUcs4ToUtf16, libs, "g_ucs4_to_utf16")
1715 core.PuregoSafeRegister(&xUcs4ToUtf8, libs, "g_ucs4_to_utf8")
1716 core.PuregoSafeRegister(&xUnicharBreakType, libs, "g_unichar_break_type")
1717 core.PuregoSafeRegister(&xUnicharCombiningClass, libs, "g_unichar_combining_class")
1718 core.PuregoSafeRegister(&xUnicharCompose, libs, "g_unichar_compose")
1719 core.PuregoSafeRegister(&xUnicharDecompose, libs, "g_unichar_decompose")
1720 core.PuregoSafeRegister(&xUnicharDigitValue, libs, "g_unichar_digit_value")
1721 core.PuregoSafeRegister(&xUnicharFullyDecompose, libs, "g_unichar_fully_decompose")
1722 core.PuregoSafeRegister(&xUnicharGetMirrorChar, libs, "g_unichar_get_mirror_char")
1723 core.PuregoSafeRegister(&xUnicharGetScript, libs, "g_unichar_get_script")
1724 core.PuregoSafeRegister(&xUnicharIsalnum, libs, "g_unichar_isalnum")
1725 core.PuregoSafeRegister(&xUnicharIsalpha, libs, "g_unichar_isalpha")
1726 core.PuregoSafeRegister(&xUnicharIscntrl, libs, "g_unichar_iscntrl")
1727 core.PuregoSafeRegister(&xUnicharIsdefined, libs, "g_unichar_isdefined")
1728 core.PuregoSafeRegister(&xUnicharIsdigit, libs, "g_unichar_isdigit")
1729 core.PuregoSafeRegister(&xUnicharIsgraph, libs, "g_unichar_isgraph")
1730 core.PuregoSafeRegister(&xUnicharIslower, libs, "g_unichar_islower")
1731 core.PuregoSafeRegister(&xUnicharIsmark, libs, "g_unichar_ismark")
1732 core.PuregoSafeRegister(&xUnicharIsprint, libs, "g_unichar_isprint")
1733 core.PuregoSafeRegister(&xUnicharIspunct, libs, "g_unichar_ispunct")
1734 core.PuregoSafeRegister(&xUnicharIsspace, libs, "g_unichar_isspace")
1735 core.PuregoSafeRegister(&xUnicharIstitle, libs, "g_unichar_istitle")
1736 core.PuregoSafeRegister(&xUnicharIsupper, libs, "g_unichar_isupper")
1737 core.PuregoSafeRegister(&xUnicharIswide, libs, "g_unichar_iswide")
1738 core.PuregoSafeRegister(&xUnicharIswideCjk, libs, "g_unichar_iswide_cjk")
1739 core.PuregoSafeRegister(&xUnicharIsxdigit, libs, "g_unichar_isxdigit")
1740 core.PuregoSafeRegister(&xUnicharIszerowidth, libs, "g_unichar_iszerowidth")
1741 core.PuregoSafeRegister(&xUnicharToUtf8, libs, "g_unichar_to_utf8")
1742 core.PuregoSafeRegister(&xUnicharTolower, libs, "g_unichar_tolower")
1743 core.PuregoSafeRegister(&xUnicharTotitle, libs, "g_unichar_totitle")
1744 core.PuregoSafeRegister(&xUnicharToupper, libs, "g_unichar_toupper")
1745 core.PuregoSafeRegister(&xUnicharType, libs, "g_unichar_type")
1746 core.PuregoSafeRegister(&xUnicharValidate, libs, "g_unichar_validate")
1747 core.PuregoSafeRegister(&xUnicharXdigitValue, libs, "g_unichar_xdigit_value")
1748 core.PuregoSafeRegister(&xUnicodeCanonicalDecomposition, libs, "g_unicode_canonical_decomposition")
1749 core.PuregoSafeRegister(&xUnicodeCanonicalOrdering, libs, "g_unicode_canonical_ordering")
1750 core.PuregoSafeRegister(&xUnicodeScriptFromIso15924, libs, "g_unicode_script_from_iso15924")
1751 core.PuregoSafeRegister(&xUnicodeScriptToIso15924, libs, "g_unicode_script_to_iso15924")
1752 core.PuregoSafeRegister(&xUtf16ToUcs4, libs, "g_utf16_to_ucs4")
1753 core.PuregoSafeRegister(&xUtf16ToUtf8, libs, "g_utf16_to_utf8")
1754 core.PuregoSafeRegister(&xUtf8Casefold, libs, "g_utf8_casefold")
1755 core.PuregoSafeRegister(&xUtf8Collate, libs, "g_utf8_collate")
1756 core.PuregoSafeRegister(&xUtf8CollateKey, libs, "g_utf8_collate_key")
1757 core.PuregoSafeRegister(&xUtf8CollateKeyForFilename, libs, "g_utf8_collate_key_for_filename")
1758 core.PuregoSafeRegister(&xUtf8FindNextChar, libs, "g_utf8_find_next_char")
1759 core.PuregoSafeRegister(&xUtf8FindPrevChar, libs, "g_utf8_find_prev_char")
1760 core.PuregoSafeRegister(&xUtf8GetChar, libs, "g_utf8_get_char")
1761 core.PuregoSafeRegister(&xUtf8GetCharValidated, libs, "g_utf8_get_char_validated")
1762 core.PuregoSafeRegister(&xUtf8MakeValid, libs, "g_utf8_make_valid")
1763 core.PuregoSafeRegister(&xUtf8Normalize, libs, "g_utf8_normalize")
1764 core.PuregoSafeRegister(&xUtf8OffsetToPointer, libs, "g_utf8_offset_to_pointer")
1765 core.PuregoSafeRegister(&xUtf8PointerToOffset, libs, "g_utf8_pointer_to_offset")
1766 core.PuregoSafeRegister(&xUtf8PrevChar, libs, "g_utf8_prev_char")
1767 core.PuregoSafeRegister(&xUtf8Strchr, libs, "g_utf8_strchr")
1768 core.PuregoSafeRegister(&xUtf8Strdown, libs, "g_utf8_strdown")
1769 core.PuregoSafeRegister(&xUtf8Strlen, libs, "g_utf8_strlen")
1770 core.PuregoSafeRegister(&xUtf8Strncpy, libs, "g_utf8_strncpy")
1771 core.PuregoSafeRegister(&xUtf8Strrchr, libs, "g_utf8_strrchr")
1772 core.PuregoSafeRegister(&xUtf8Strreverse, libs, "g_utf8_strreverse")
1773 core.PuregoSafeRegister(&xUtf8Strup, libs, "g_utf8_strup")
1774 core.PuregoSafeRegister(&xUtf8Substring, libs, "g_utf8_substring")
1775 core.PuregoSafeRegister(&xUtf8ToUcs4, libs, "g_utf8_to_ucs4")
1776 core.PuregoSafeRegister(&xUtf8ToUcs4Fast, libs, "g_utf8_to_ucs4_fast")
1777 core.PuregoSafeRegister(&xUtf8ToUtf16, libs, "g_utf8_to_utf16")
1778 core.PuregoSafeRegister(&xUtf8TruncateMiddle, libs, "g_utf8_truncate_middle")
1779 core.PuregoSafeRegister(&xUtf8Validate, libs, "g_utf8_validate")
1780 core.PuregoSafeRegister(&xUtf8ValidateLen, libs, "g_utf8_validate_len")
1781
1782}