CoCalc -- xmlunicode.c

GitHub Repository: wine-mirror/wine
Path: blob/master/libs/xml2/xmlunicode.c
⁴³⁸⁹ views
1
/*
2
 * xmlunicode.c: this module implements the Unicode character APIs
3
 *
4
 * This file is automatically generated from the
5
 * UCS description files of the Unicode Character Database
6
 * http://www.unicode.org/Public/4.0-Update1/UCD-4.0.1.html
7
 * using the genUnicode.py Python script.
8
 *
9
 * Generation date: Mon Mar 27 11:09:52 2006
10
 * Sources: Blocks-4.0.1.txt UnicodeData-4.0.1.txt
11
 * Daniel Veillard <[email protected]>
12
 */
13

14
#define IN_LIBXML
15
#include "libxml.h"
16

17
#ifdef LIBXML_UNICODE_ENABLED
18

19
#include <string.h>
20
#include <libxml/xmlversion.h>
21
#include <libxml/xmlunicode.h>
22
#include <libxml/chvalid.h>
23

24
typedef int (xmlIntFunc)(int);	/* just to keep one's mind untwisted */
25

26
typedef struct {
27
    const char *rangename;
28
    xmlIntFunc *func;
29
} xmlUnicodeRange;
30

31
typedef struct {
32
    const xmlUnicodeRange *table;
33
    int		    numentries;
34
} xmlUnicodeNameTable;
35

36

37
static xmlIntFunc *xmlUnicodeLookup(const xmlUnicodeNameTable *tptr, const char *tname);
38

39
static const xmlUnicodeRange xmlUnicodeBlocks[] = {
40
  {"AegeanNumbers", xmlUCSIsAegeanNumbers},
41
  {"AlphabeticPresentationForms", xmlUCSIsAlphabeticPresentationForms},
42
  {"Arabic", xmlUCSIsArabic},
43
  {"ArabicPresentationForms-A", xmlUCSIsArabicPresentationFormsA},
44
  {"ArabicPresentationForms-B", xmlUCSIsArabicPresentationFormsB},
45
  {"Armenian", xmlUCSIsArmenian},
46
  {"Arrows", xmlUCSIsArrows},
47
  {"BasicLatin", xmlUCSIsBasicLatin},
48
  {"Bengali", xmlUCSIsBengali},
49
  {"BlockElements", xmlUCSIsBlockElements},
50
  {"Bopomofo", xmlUCSIsBopomofo},
51
  {"BopomofoExtended", xmlUCSIsBopomofoExtended},
52
  {"BoxDrawing", xmlUCSIsBoxDrawing},
53
  {"BraillePatterns", xmlUCSIsBraillePatterns},
54
  {"Buhid", xmlUCSIsBuhid},
55
  {"ByzantineMusicalSymbols", xmlUCSIsByzantineMusicalSymbols},
56
  {"CJKCompatibility", xmlUCSIsCJKCompatibility},
57
  {"CJKCompatibilityForms", xmlUCSIsCJKCompatibilityForms},
58
  {"CJKCompatibilityIdeographs", xmlUCSIsCJKCompatibilityIdeographs},
59
  {"CJKCompatibilityIdeographsSupplement", xmlUCSIsCJKCompatibilityIdeographsSupplement},
60
  {"CJKRadicalsSupplement", xmlUCSIsCJKRadicalsSupplement},
61
  {"CJKSymbolsandPunctuation", xmlUCSIsCJKSymbolsandPunctuation},
62
  {"CJKUnifiedIdeographs", xmlUCSIsCJKUnifiedIdeographs},
63
  {"CJKUnifiedIdeographsExtensionA", xmlUCSIsCJKUnifiedIdeographsExtensionA},
64
  {"CJKUnifiedIdeographsExtensionB", xmlUCSIsCJKUnifiedIdeographsExtensionB},
65
  {"Cherokee", xmlUCSIsCherokee},
66
  {"CombiningDiacriticalMarks", xmlUCSIsCombiningDiacriticalMarks},
67
  {"CombiningDiacriticalMarksforSymbols", xmlUCSIsCombiningDiacriticalMarksforSymbols},
68
  {"CombiningHalfMarks", xmlUCSIsCombiningHalfMarks},
69
  {"CombiningMarksforSymbols", xmlUCSIsCombiningMarksforSymbols},
70
  {"ControlPictures", xmlUCSIsControlPictures},
71
  {"CurrencySymbols", xmlUCSIsCurrencySymbols},
72
  {"CypriotSyllabary", xmlUCSIsCypriotSyllabary},
73
  {"Cyrillic", xmlUCSIsCyrillic},
74
  {"CyrillicSupplement", xmlUCSIsCyrillicSupplement},
75
  {"Deseret", xmlUCSIsDeseret},
76
  {"Devanagari", xmlUCSIsDevanagari},
77
  {"Dingbats", xmlUCSIsDingbats},
78
  {"EnclosedAlphanumerics", xmlUCSIsEnclosedAlphanumerics},
79
  {"EnclosedCJKLettersandMonths", xmlUCSIsEnclosedCJKLettersandMonths},
80
  {"Ethiopic", xmlUCSIsEthiopic},
81
  {"GeneralPunctuation", xmlUCSIsGeneralPunctuation},
82
  {"GeometricShapes", xmlUCSIsGeometricShapes},
83
  {"Georgian", xmlUCSIsGeorgian},
84
  {"Gothic", xmlUCSIsGothic},
85
  {"Greek", xmlUCSIsGreek},
86
  {"GreekExtended", xmlUCSIsGreekExtended},
87
  {"GreekandCoptic", xmlUCSIsGreekandCoptic},
88
  {"Gujarati", xmlUCSIsGujarati},
89
  {"Gurmukhi", xmlUCSIsGurmukhi},
90
  {"HalfwidthandFullwidthForms", xmlUCSIsHalfwidthandFullwidthForms},
91
  {"HangulCompatibilityJamo", xmlUCSIsHangulCompatibilityJamo},
92
  {"HangulJamo", xmlUCSIsHangulJamo},
93
  {"HangulSyllables", xmlUCSIsHangulSyllables},
94
  {"Hanunoo", xmlUCSIsHanunoo},
95
  {"Hebrew", xmlUCSIsHebrew},
96
  {"HighPrivateUseSurrogates", xmlUCSIsHighPrivateUseSurrogates},
97
  {"HighSurrogates", xmlUCSIsHighSurrogates},
98
  {"Hiragana", xmlUCSIsHiragana},
99
  {"IPAExtensions", xmlUCSIsIPAExtensions},
100
  {"IdeographicDescriptionCharacters", xmlUCSIsIdeographicDescriptionCharacters},
101
  {"Kanbun", xmlUCSIsKanbun},
102
  {"KangxiRadicals", xmlUCSIsKangxiRadicals},
103
  {"Kannada", xmlUCSIsKannada},
104
  {"Katakana", xmlUCSIsKatakana},
105
  {"KatakanaPhoneticExtensions", xmlUCSIsKatakanaPhoneticExtensions},
106
  {"Khmer", xmlUCSIsKhmer},
107
  {"KhmerSymbols", xmlUCSIsKhmerSymbols},
108
  {"Lao", xmlUCSIsLao},
109
  {"Latin-1Supplement", xmlUCSIsLatin1Supplement},
110
  {"LatinExtended-A", xmlUCSIsLatinExtendedA},
111
  {"LatinExtended-B", xmlUCSIsLatinExtendedB},
112
  {"LatinExtendedAdditional", xmlUCSIsLatinExtendedAdditional},
113
  {"LetterlikeSymbols", xmlUCSIsLetterlikeSymbols},
114
  {"Limbu", xmlUCSIsLimbu},
115
  {"LinearBIdeograms", xmlUCSIsLinearBIdeograms},
116
  {"LinearBSyllabary", xmlUCSIsLinearBSyllabary},
117
  {"LowSurrogates", xmlUCSIsLowSurrogates},
118
  {"Malayalam", xmlUCSIsMalayalam},
119
  {"MathematicalAlphanumericSymbols", xmlUCSIsMathematicalAlphanumericSymbols},
120
  {"MathematicalOperators", xmlUCSIsMathematicalOperators},
121
  {"MiscellaneousMathematicalSymbols-A", xmlUCSIsMiscellaneousMathematicalSymbolsA},
122
  {"MiscellaneousMathematicalSymbols-B", xmlUCSIsMiscellaneousMathematicalSymbolsB},
123
  {"MiscellaneousSymbols", xmlUCSIsMiscellaneousSymbols},
124
  {"MiscellaneousSymbolsandArrows", xmlUCSIsMiscellaneousSymbolsandArrows},
125
  {"MiscellaneousTechnical", xmlUCSIsMiscellaneousTechnical},
126
  {"Mongolian", xmlUCSIsMongolian},
127
  {"MusicalSymbols", xmlUCSIsMusicalSymbols},
128
  {"Myanmar", xmlUCSIsMyanmar},
129
  {"NumberForms", xmlUCSIsNumberForms},
130
  {"Ogham", xmlUCSIsOgham},
131
  {"OldItalic", xmlUCSIsOldItalic},
132
  {"OpticalCharacterRecognition", xmlUCSIsOpticalCharacterRecognition},
133
  {"Oriya", xmlUCSIsOriya},
134
  {"Osmanya", xmlUCSIsOsmanya},
135
  {"PhoneticExtensions", xmlUCSIsPhoneticExtensions},
136
  {"PrivateUse", xmlUCSIsPrivateUse},
137
  {"PrivateUseArea", xmlUCSIsPrivateUseArea},
138
  {"Runic", xmlUCSIsRunic},
139
  {"Shavian", xmlUCSIsShavian},
140
  {"Sinhala", xmlUCSIsSinhala},
141
  {"SmallFormVariants", xmlUCSIsSmallFormVariants},
142
  {"SpacingModifierLetters", xmlUCSIsSpacingModifierLetters},
143
  {"Specials", xmlUCSIsSpecials},
144
  {"SuperscriptsandSubscripts", xmlUCSIsSuperscriptsandSubscripts},
145
  {"SupplementalArrows-A", xmlUCSIsSupplementalArrowsA},
146
  {"SupplementalArrows-B", xmlUCSIsSupplementalArrowsB},
147
  {"SupplementalMathematicalOperators", xmlUCSIsSupplementalMathematicalOperators},
148
  {"SupplementaryPrivateUseArea-A", xmlUCSIsSupplementaryPrivateUseAreaA},
149
  {"SupplementaryPrivateUseArea-B", xmlUCSIsSupplementaryPrivateUseAreaB},
150
  {"Syriac", xmlUCSIsSyriac},
151
  {"Tagalog", xmlUCSIsTagalog},
152
  {"Tagbanwa", xmlUCSIsTagbanwa},
153
  {"Tags", xmlUCSIsTags},
154
  {"TaiLe", xmlUCSIsTaiLe},
155
  {"TaiXuanJingSymbols", xmlUCSIsTaiXuanJingSymbols},
156
  {"Tamil", xmlUCSIsTamil},
157
  {"Telugu", xmlUCSIsTelugu},
158
  {"Thaana", xmlUCSIsThaana},
159
  {"Thai", xmlUCSIsThai},
160
  {"Tibetan", xmlUCSIsTibetan},
161
  {"Ugaritic", xmlUCSIsUgaritic},
162
  {"UnifiedCanadianAboriginalSyllabics", xmlUCSIsUnifiedCanadianAboriginalSyllabics},
163
  {"VariationSelectors", xmlUCSIsVariationSelectors},
164
  {"VariationSelectorsSupplement", xmlUCSIsVariationSelectorsSupplement},
165
  {"YiRadicals", xmlUCSIsYiRadicals},
166
  {"YiSyllables", xmlUCSIsYiSyllables},
167
  {"YijingHexagramSymbols", xmlUCSIsYijingHexagramSymbols}};
168

169
static const xmlUnicodeRange xmlUnicodeCats[] = {
170
  {"C", xmlUCSIsCatC},
171
  {"Cc", xmlUCSIsCatCc},
172
  {"Cf", xmlUCSIsCatCf},
173
  {"Co", xmlUCSIsCatCo},
174
  {"Cs", xmlUCSIsCatCs},
175
  {"L", xmlUCSIsCatL},
176
  {"Ll", xmlUCSIsCatLl},
177
  {"Lm", xmlUCSIsCatLm},
178
  {"Lo", xmlUCSIsCatLo},
179
  {"Lt", xmlUCSIsCatLt},
180
  {"Lu", xmlUCSIsCatLu},
181
  {"M", xmlUCSIsCatM},
182
  {"Mc", xmlUCSIsCatMc},
183
  {"Me", xmlUCSIsCatMe},
184
  {"Mn", xmlUCSIsCatMn},
185
  {"N", xmlUCSIsCatN},
186
  {"Nd", xmlUCSIsCatNd},
187
  {"Nl", xmlUCSIsCatNl},
188
  {"No", xmlUCSIsCatNo},
189
  {"P", xmlUCSIsCatP},
190
  {"Pc", xmlUCSIsCatPc},
191
  {"Pd", xmlUCSIsCatPd},
192
  {"Pe", xmlUCSIsCatPe},
193
  {"Pf", xmlUCSIsCatPf},
194
  {"Pi", xmlUCSIsCatPi},
195
  {"Po", xmlUCSIsCatPo},
196
  {"Ps", xmlUCSIsCatPs},
197
  {"S", xmlUCSIsCatS},
198
  {"Sc", xmlUCSIsCatSc},
199
  {"Sk", xmlUCSIsCatSk},
200
  {"Sm", xmlUCSIsCatSm},
201
  {"So", xmlUCSIsCatSo},
202
  {"Z", xmlUCSIsCatZ},
203
  {"Zl", xmlUCSIsCatZl},
204
  {"Zp", xmlUCSIsCatZp},
205
  {"Zs", xmlUCSIsCatZs}};
206

207
static const xmlChSRange xmlCS[] = {{0x0, 0x1f}, {0x7f, 0x9f},
208
    {0xad, 0xad}, {0x600, 0x603}, {0x6dd, 0x6dd}, {0x70f, 0x70f},
209
    {0x17b4, 0x17b5}, {0x200b, 0x200f}, {0x202a, 0x202e}, {0x2060, 0x2063},
210
    {0x206a, 0x206f}, {0xd800, 0xd800}, {0xdb7f, 0xdb80}, {0xdbff, 0xdc00},
211
    {0xdfff, 0xe000}, {0xf8ff, 0xf8ff}, {0xfeff, 0xfeff}, {0xfff9, 0xfffb} };
212
static const xmlChLRange xmlCL[] = {{0x1d173, 0x1d17a}, {0xe0001, 0xe0001},
213
    {0xe0020, 0xe007f}, {0xf0000, 0xf0000}, {0xffffd, 0xffffd},
214
    {0x100000, 0x100000}, {0x10fffd, 0x10fffd} };
215
static const xmlChRangeGroup xmlCG = {18,7,xmlCS,xmlCL};
216

217
static const xmlChSRange xmlCfS[] = {{0xad, 0xad}, {0x600, 0x603},
218
    {0x6dd, 0x6dd}, {0x70f, 0x70f}, {0x17b4, 0x17b5}, {0x200b, 0x200f},
219
    {0x202a, 0x202e}, {0x2060, 0x2063}, {0x206a, 0x206f}, {0xfeff, 0xfeff},
220
    {0xfff9, 0xfffb} };
221
static const xmlChLRange xmlCfL[] = {{0x1d173, 0x1d17a}, {0xe0001, 0xe0001},
222
    {0xe0020, 0xe007f} };
223
static const xmlChRangeGroup xmlCfG = {11,3,xmlCfS,xmlCfL};
224

225
static const xmlChSRange xmlLS[] = {{0x41, 0x5a}, {0x61, 0x7a},
226
    {0xaa, 0xaa}, {0xb5, 0xb5}, {0xba, 0xba}, {0xc0, 0xd6}, {0xd8, 0xf6},
227
    {0xf8, 0x236}, {0x250, 0x2c1}, {0x2c6, 0x2d1}, {0x2e0, 0x2e4},
228
    {0x2ee, 0x2ee}, {0x37a, 0x37a}, {0x386, 0x386}, {0x388, 0x38a},
229
    {0x38c, 0x38c}, {0x38e, 0x3a1}, {0x3a3, 0x3ce}, {0x3d0, 0x3f5},
230
    {0x3f7, 0x3fb}, {0x400, 0x481}, {0x48a, 0x4ce}, {0x4d0, 0x4f5},
231
    {0x4f8, 0x4f9}, {0x500, 0x50f}, {0x531, 0x556}, {0x559, 0x559},
232
    {0x561, 0x587}, {0x5d0, 0x5ea}, {0x5f0, 0x5f2}, {0x621, 0x63a},
233
    {0x640, 0x64a}, {0x66e, 0x66f}, {0x671, 0x6d3}, {0x6d5, 0x6d5},
234
    {0x6e5, 0x6e6}, {0x6ee, 0x6ef}, {0x6fa, 0x6fc}, {0x6ff, 0x6ff},
235
    {0x710, 0x710}, {0x712, 0x72f}, {0x74d, 0x74f}, {0x780, 0x7a5},
236
    {0x7b1, 0x7b1}, {0x904, 0x939}, {0x93d, 0x93d}, {0x950, 0x950},
237
    {0x958, 0x961}, {0x985, 0x98c}, {0x98f, 0x990}, {0x993, 0x9a8},
238
    {0x9aa, 0x9b0}, {0x9b2, 0x9b2}, {0x9b6, 0x9b9}, {0x9bd, 0x9bd},
239
    {0x9dc, 0x9dd}, {0x9df, 0x9e1}, {0x9f0, 0x9f1}, {0xa05, 0xa0a},
240
    {0xa0f, 0xa10}, {0xa13, 0xa28}, {0xa2a, 0xa30}, {0xa32, 0xa33},
241
    {0xa35, 0xa36}, {0xa38, 0xa39}, {0xa59, 0xa5c}, {0xa5e, 0xa5e},
242
    {0xa72, 0xa74}, {0xa85, 0xa8d}, {0xa8f, 0xa91}, {0xa93, 0xaa8},
243
    {0xaaa, 0xab0}, {0xab2, 0xab3}, {0xab5, 0xab9}, {0xabd, 0xabd},
244
    {0xad0, 0xad0}, {0xae0, 0xae1}, {0xb05, 0xb0c}, {0xb0f, 0xb10},
245
    {0xb13, 0xb28}, {0xb2a, 0xb30}, {0xb32, 0xb33}, {0xb35, 0xb39},
246
    {0xb3d, 0xb3d}, {0xb5c, 0xb5d}, {0xb5f, 0xb61}, {0xb71, 0xb71},
247
    {0xb83, 0xb83}, {0xb85, 0xb8a}, {0xb8e, 0xb90}, {0xb92, 0xb95},
248
    {0xb99, 0xb9a}, {0xb9c, 0xb9c}, {0xb9e, 0xb9f}, {0xba3, 0xba4},
249
    {0xba8, 0xbaa}, {0xbae, 0xbb5}, {0xbb7, 0xbb9}, {0xc05, 0xc0c},
250
    {0xc0e, 0xc10}, {0xc12, 0xc28}, {0xc2a, 0xc33}, {0xc35, 0xc39},
251
    {0xc60, 0xc61}, {0xc85, 0xc8c}, {0xc8e, 0xc90}, {0xc92, 0xca8},
252
    {0xcaa, 0xcb3}, {0xcb5, 0xcb9}, {0xcbd, 0xcbd}, {0xcde, 0xcde},
253
    {0xce0, 0xce1}, {0xd05, 0xd0c}, {0xd0e, 0xd10}, {0xd12, 0xd28},
254
    {0xd2a, 0xd39}, {0xd60, 0xd61}, {0xd85, 0xd96}, {0xd9a, 0xdb1},
255
    {0xdb3, 0xdbb}, {0xdbd, 0xdbd}, {0xdc0, 0xdc6}, {0xe01, 0xe30},
256
    {0xe32, 0xe33}, {0xe40, 0xe46}, {0xe81, 0xe82}, {0xe84, 0xe84},
257
    {0xe87, 0xe88}, {0xe8a, 0xe8a}, {0xe8d, 0xe8d}, {0xe94, 0xe97},
258
    {0xe99, 0xe9f}, {0xea1, 0xea3}, {0xea5, 0xea5}, {0xea7, 0xea7},
259
    {0xeaa, 0xeab}, {0xead, 0xeb0}, {0xeb2, 0xeb3}, {0xebd, 0xebd},
260
    {0xec0, 0xec4}, {0xec6, 0xec6}, {0xedc, 0xedd}, {0xf00, 0xf00},
261
    {0xf40, 0xf47}, {0xf49, 0xf6a}, {0xf88, 0xf8b}, {0x1000, 0x1021},
262
    {0x1023, 0x1027}, {0x1029, 0x102a}, {0x1050, 0x1055}, {0x10a0, 0x10c5},
263
    {0x10d0, 0x10f8}, {0x1100, 0x1159}, {0x115f, 0x11a2}, {0x11a8, 0x11f9},
264
    {0x1200, 0x1206}, {0x1208, 0x1246}, {0x1248, 0x1248}, {0x124a, 0x124d},
265
    {0x1250, 0x1256}, {0x1258, 0x1258}, {0x125a, 0x125d}, {0x1260, 0x1286},
266
    {0x1288, 0x1288}, {0x128a, 0x128d}, {0x1290, 0x12ae}, {0x12b0, 0x12b0},
267
    {0x12b2, 0x12b5}, {0x12b8, 0x12be}, {0x12c0, 0x12c0}, {0x12c2, 0x12c5},
268
    {0x12c8, 0x12ce}, {0x12d0, 0x12d6}, {0x12d8, 0x12ee}, {0x12f0, 0x130e},
269
    {0x1310, 0x1310}, {0x1312, 0x1315}, {0x1318, 0x131e}, {0x1320, 0x1346},
270
    {0x1348, 0x135a}, {0x13a0, 0x13f4}, {0x1401, 0x166c}, {0x166f, 0x1676},
271
    {0x1681, 0x169a}, {0x16a0, 0x16ea}, {0x1700, 0x170c}, {0x170e, 0x1711},
272
    {0x1720, 0x1731}, {0x1740, 0x1751}, {0x1760, 0x176c}, {0x176e, 0x1770},
273
    {0x1780, 0x17b3}, {0x17d7, 0x17d7}, {0x17dc, 0x17dc}, {0x1820, 0x1877},
274
    {0x1880, 0x18a8}, {0x1900, 0x191c}, {0x1950, 0x196d}, {0x1970, 0x1974},
275
    {0x1d00, 0x1d6b}, {0x1e00, 0x1e9b}, {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15},
276
    {0x1f18, 0x1f1d}, {0x1f20, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57},
277
    {0x1f59, 0x1f59}, {0x1f5b, 0x1f5b}, {0x1f5d, 0x1f5d}, {0x1f5f, 0x1f7d},
278
    {0x1f80, 0x1fb4}, {0x1fb6, 0x1fbc}, {0x1fbe, 0x1fbe}, {0x1fc2, 0x1fc4},
279
    {0x1fc6, 0x1fcc}, {0x1fd0, 0x1fd3}, {0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec},
280
    {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc}, {0x2071, 0x2071}, {0x207f, 0x207f},
281
    {0x2102, 0x2102}, {0x2107, 0x2107}, {0x210a, 0x2113}, {0x2115, 0x2115},
282
    {0x2119, 0x211d}, {0x2124, 0x2124}, {0x2126, 0x2126}, {0x2128, 0x2128},
283
    {0x212a, 0x212d}, {0x212f, 0x2131}, {0x2133, 0x2139}, {0x213d, 0x213f},
284
    {0x2145, 0x2149}, {0x3005, 0x3006}, {0x3031, 0x3035}, {0x303b, 0x303c},
285
    {0x3041, 0x3096}, {0x309d, 0x309f}, {0x30a1, 0x30fa}, {0x30fc, 0x30ff},
286
    {0x3105, 0x312c}, {0x3131, 0x318e}, {0x31a0, 0x31b7}, {0x31f0, 0x31ff},
287
    {0x3400, 0x3400}, {0x4db5, 0x4db5}, {0x4e00, 0x4e00}, {0x9fa5, 0x9fa5},
288
    {0xa000, 0xa48c}, {0xac00, 0xac00}, {0xd7a3, 0xd7a3}, {0xf900, 0xfa2d},
289
    {0xfa30, 0xfa6a}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xfb1d, 0xfb1d},
290
    {0xfb1f, 0xfb28}, {0xfb2a, 0xfb36}, {0xfb38, 0xfb3c}, {0xfb3e, 0xfb3e},
291
    {0xfb40, 0xfb41}, {0xfb43, 0xfb44}, {0xfb46, 0xfbb1}, {0xfbd3, 0xfd3d},
292
    {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb}, {0xfe70, 0xfe74},
293
    {0xfe76, 0xfefc}, {0xff21, 0xff3a}, {0xff41, 0xff5a}, {0xff66, 0xffbe},
294
    {0xffc2, 0xffc7}, {0xffca, 0xffcf}, {0xffd2, 0xffd7}, {0xffda, 0xffdc} };
295
static const xmlChLRange xmlLL[] = {{0x10000, 0x1000b}, {0x1000d, 0x10026},
296
    {0x10028, 0x1003a}, {0x1003c, 0x1003d}, {0x1003f, 0x1004d},
297
    {0x10050, 0x1005d}, {0x10080, 0x100fa}, {0x10300, 0x1031e},
298
    {0x10330, 0x10349}, {0x10380, 0x1039d}, {0x10400, 0x1049d},
299
    {0x10800, 0x10805}, {0x10808, 0x10808}, {0x1080a, 0x10835},
300
    {0x10837, 0x10838}, {0x1083c, 0x1083c}, {0x1083f, 0x1083f},
301
    {0x1d400, 0x1d454}, {0x1d456, 0x1d49c}, {0x1d49e, 0x1d49f},
302
    {0x1d4a2, 0x1d4a2}, {0x1d4a5, 0x1d4a6}, {0x1d4a9, 0x1d4ac},
303
    {0x1d4ae, 0x1d4b9}, {0x1d4bb, 0x1d4bb}, {0x1d4bd, 0x1d4c3},
304
    {0x1d4c5, 0x1d505}, {0x1d507, 0x1d50a}, {0x1d50d, 0x1d514},
305
    {0x1d516, 0x1d51c}, {0x1d51e, 0x1d539}, {0x1d53b, 0x1d53e},
306
    {0x1d540, 0x1d544}, {0x1d546, 0x1d546}, {0x1d54a, 0x1d550},
307
    {0x1d552, 0x1d6a3}, {0x1d6a8, 0x1d6c0}, {0x1d6c2, 0x1d6da},
308
    {0x1d6dc, 0x1d6fa}, {0x1d6fc, 0x1d714}, {0x1d716, 0x1d734},
309
    {0x1d736, 0x1d74e}, {0x1d750, 0x1d76e}, {0x1d770, 0x1d788},
310
    {0x1d78a, 0x1d7a8}, {0x1d7aa, 0x1d7c2}, {0x1d7c4, 0x1d7c9},
311
    {0x20000, 0x20000}, {0x2a6d6, 0x2a6d6}, {0x2f800, 0x2fa1d} };
312
static const xmlChRangeGroup xmlLG = {279,50,xmlLS,xmlLL};
313

314
static const xmlChSRange xmlLlS[] = {{0x61, 0x7a}, {0xaa, 0xaa},
315
    {0xb5, 0xb5}, {0xba, 0xba}, {0xdf, 0xf6}, {0xf8, 0xff}, {0x101, 0x101},
316
    {0x103, 0x103}, {0x105, 0x105}, {0x107, 0x107}, {0x109, 0x109},
317
    {0x10b, 0x10b}, {0x10d, 0x10d}, {0x10f, 0x10f}, {0x111, 0x111},
318
    {0x113, 0x113}, {0x115, 0x115}, {0x117, 0x117}, {0x119, 0x119},
319
    {0x11b, 0x11b}, {0x11d, 0x11d}, {0x11f, 0x11f}, {0x121, 0x121},
320
    {0x123, 0x123}, {0x125, 0x125}, {0x127, 0x127}, {0x129, 0x129},
321
    {0x12b, 0x12b}, {0x12d, 0x12d}, {0x12f, 0x12f}, {0x131, 0x131},
322
    {0x133, 0x133}, {0x135, 0x135}, {0x137, 0x138}, {0x13a, 0x13a},
323
    {0x13c, 0x13c}, {0x13e, 0x13e}, {0x140, 0x140}, {0x142, 0x142},
324
    {0x144, 0x144}, {0x146, 0x146}, {0x148, 0x149}, {0x14b, 0x14b},
325
    {0x14d, 0x14d}, {0x14f, 0x14f}, {0x151, 0x151}, {0x153, 0x153},
326
    {0x155, 0x155}, {0x157, 0x157}, {0x159, 0x159}, {0x15b, 0x15b},
327
    {0x15d, 0x15d}, {0x15f, 0x15f}, {0x161, 0x161}, {0x163, 0x163},
328
    {0x165, 0x165}, {0x167, 0x167}, {0x169, 0x169}, {0x16b, 0x16b},
329
    {0x16d, 0x16d}, {0x16f, 0x16f}, {0x171, 0x171}, {0x173, 0x173},
330
    {0x175, 0x175}, {0x177, 0x177}, {0x17a, 0x17a}, {0x17c, 0x17c},
331
    {0x17e, 0x180}, {0x183, 0x183}, {0x185, 0x185}, {0x188, 0x188},
332
    {0x18c, 0x18d}, {0x192, 0x192}, {0x195, 0x195}, {0x199, 0x19b},
333
    {0x19e, 0x19e}, {0x1a1, 0x1a1}, {0x1a3, 0x1a3}, {0x1a5, 0x1a5},
334
    {0x1a8, 0x1a8}, {0x1aa, 0x1ab}, {0x1ad, 0x1ad}, {0x1b0, 0x1b0},
335
    {0x1b4, 0x1b4}, {0x1b6, 0x1b6}, {0x1b9, 0x1ba}, {0x1bd, 0x1bf},
336
    {0x1c6, 0x1c6}, {0x1c9, 0x1c9}, {0x1cc, 0x1cc}, {0x1ce, 0x1ce},
337
    {0x1d0, 0x1d0}, {0x1d2, 0x1d2}, {0x1d4, 0x1d4}, {0x1d6, 0x1d6},
338
    {0x1d8, 0x1d8}, {0x1da, 0x1da}, {0x1dc, 0x1dd}, {0x1df, 0x1df},
339
    {0x1e1, 0x1e1}, {0x1e3, 0x1e3}, {0x1e5, 0x1e5}, {0x1e7, 0x1e7},
340
    {0x1e9, 0x1e9}, {0x1eb, 0x1eb}, {0x1ed, 0x1ed}, {0x1ef, 0x1f0},
341
    {0x1f3, 0x1f3}, {0x1f5, 0x1f5}, {0x1f9, 0x1f9}, {0x1fb, 0x1fb},
342
    {0x1fd, 0x1fd}, {0x1ff, 0x1ff}, {0x201, 0x201}, {0x203, 0x203},
343
    {0x205, 0x205}, {0x207, 0x207}, {0x209, 0x209}, {0x20b, 0x20b},
344
    {0x20d, 0x20d}, {0x20f, 0x20f}, {0x211, 0x211}, {0x213, 0x213},
345
    {0x215, 0x215}, {0x217, 0x217}, {0x219, 0x219}, {0x21b, 0x21b},
346
    {0x21d, 0x21d}, {0x21f, 0x21f}, {0x221, 0x221}, {0x223, 0x223},
347
    {0x225, 0x225}, {0x227, 0x227}, {0x229, 0x229}, {0x22b, 0x22b},
348
    {0x22d, 0x22d}, {0x22f, 0x22f}, {0x231, 0x231}, {0x233, 0x236},
349
    {0x250, 0x2af}, {0x390, 0x390}, {0x3ac, 0x3ce}, {0x3d0, 0x3d1},
350
    {0x3d5, 0x3d7}, {0x3d9, 0x3d9}, {0x3db, 0x3db}, {0x3dd, 0x3dd},
351
    {0x3df, 0x3df}, {0x3e1, 0x3e1}, {0x3e3, 0x3e3}, {0x3e5, 0x3e5},
352
    {0x3e7, 0x3e7}, {0x3e9, 0x3e9}, {0x3eb, 0x3eb}, {0x3ed, 0x3ed},
353
    {0x3ef, 0x3f3}, {0x3f5, 0x3f5}, {0x3f8, 0x3f8}, {0x3fb, 0x3fb},
354
    {0x430, 0x45f}, {0x461, 0x461}, {0x463, 0x463}, {0x465, 0x465},
355
    {0x467, 0x467}, {0x469, 0x469}, {0x46b, 0x46b}, {0x46d, 0x46d},
356
    {0x46f, 0x46f}, {0x471, 0x471}, {0x473, 0x473}, {0x475, 0x475},
357
    {0x477, 0x477}, {0x479, 0x479}, {0x47b, 0x47b}, {0x47d, 0x47d},
358
    {0x47f, 0x47f}, {0x481, 0x481}, {0x48b, 0x48b}, {0x48d, 0x48d},
359
    {0x48f, 0x48f}, {0x491, 0x491}, {0x493, 0x493}, {0x495, 0x495},
360
    {0x497, 0x497}, {0x499, 0x499}, {0x49b, 0x49b}, {0x49d, 0x49d},
361
    {0x49f, 0x49f}, {0x4a1, 0x4a1}, {0x4a3, 0x4a3}, {0x4a5, 0x4a5},
362
    {0x4a7, 0x4a7}, {0x4a9, 0x4a9}, {0x4ab, 0x4ab}, {0x4ad, 0x4ad},
363
    {0x4af, 0x4af}, {0x4b1, 0x4b1}, {0x4b3, 0x4b3}, {0x4b5, 0x4b5},
364
    {0x4b7, 0x4b7}, {0x4b9, 0x4b9}, {0x4bb, 0x4bb}, {0x4bd, 0x4bd},
365
    {0x4bf, 0x4bf}, {0x4c2, 0x4c2}, {0x4c4, 0x4c4}, {0x4c6, 0x4c6},
366
    {0x4c8, 0x4c8}, {0x4ca, 0x4ca}, {0x4cc, 0x4cc}, {0x4ce, 0x4ce},
367
    {0x4d1, 0x4d1}, {0x4d3, 0x4d3}, {0x4d5, 0x4d5}, {0x4d7, 0x4d7},
368
    {0x4d9, 0x4d9}, {0x4db, 0x4db}, {0x4dd, 0x4dd}, {0x4df, 0x4df},
369
    {0x4e1, 0x4e1}, {0x4e3, 0x4e3}, {0x4e5, 0x4e5}, {0x4e7, 0x4e7},
370
    {0x4e9, 0x4e9}, {0x4eb, 0x4eb}, {0x4ed, 0x4ed}, {0x4ef, 0x4ef},
371
    {0x4f1, 0x4f1}, {0x4f3, 0x4f3}, {0x4f5, 0x4f5}, {0x4f9, 0x4f9},
372
    {0x501, 0x501}, {0x503, 0x503}, {0x505, 0x505}, {0x507, 0x507},
373
    {0x509, 0x509}, {0x50b, 0x50b}, {0x50d, 0x50d}, {0x50f, 0x50f},
374
    {0x561, 0x587}, {0x1d00, 0x1d2b}, {0x1d62, 0x1d6b}, {0x1e01, 0x1e01},
375
    {0x1e03, 0x1e03}, {0x1e05, 0x1e05}, {0x1e07, 0x1e07}, {0x1e09, 0x1e09},
376
    {0x1e0b, 0x1e0b}, {0x1e0d, 0x1e0d}, {0x1e0f, 0x1e0f}, {0x1e11, 0x1e11},
377
    {0x1e13, 0x1e13}, {0x1e15, 0x1e15}, {0x1e17, 0x1e17}, {0x1e19, 0x1e19},
378
    {0x1e1b, 0x1e1b}, {0x1e1d, 0x1e1d}, {0x1e1f, 0x1e1f}, {0x1e21, 0x1e21},
379
    {0x1e23, 0x1e23}, {0x1e25, 0x1e25}, {0x1e27, 0x1e27}, {0x1e29, 0x1e29},
380
    {0x1e2b, 0x1e2b}, {0x1e2d, 0x1e2d}, {0x1e2f, 0x1e2f}, {0x1e31, 0x1e31},
381
    {0x1e33, 0x1e33}, {0x1e35, 0x1e35}, {0x1e37, 0x1e37}, {0x1e39, 0x1e39},
382
    {0x1e3b, 0x1e3b}, {0x1e3d, 0x1e3d}, {0x1e3f, 0x1e3f}, {0x1e41, 0x1e41},
383
    {0x1e43, 0x1e43}, {0x1e45, 0x1e45}, {0x1e47, 0x1e47}, {0x1e49, 0x1e49},
384
    {0x1e4b, 0x1e4b}, {0x1e4d, 0x1e4d}, {0x1e4f, 0x1e4f}, {0x1e51, 0x1e51},
385
    {0x1e53, 0x1e53}, {0x1e55, 0x1e55}, {0x1e57, 0x1e57}, {0x1e59, 0x1e59},
386
    {0x1e5b, 0x1e5b}, {0x1e5d, 0x1e5d}, {0x1e5f, 0x1e5f}, {0x1e61, 0x1e61},
387
    {0x1e63, 0x1e63}, {0x1e65, 0x1e65}, {0x1e67, 0x1e67}, {0x1e69, 0x1e69},
388
    {0x1e6b, 0x1e6b}, {0x1e6d, 0x1e6d}, {0x1e6f, 0x1e6f}, {0x1e71, 0x1e71},
389
    {0x1e73, 0x1e73}, {0x1e75, 0x1e75}, {0x1e77, 0x1e77}, {0x1e79, 0x1e79},
390
    {0x1e7b, 0x1e7b}, {0x1e7d, 0x1e7d}, {0x1e7f, 0x1e7f}, {0x1e81, 0x1e81},
391
    {0x1e83, 0x1e83}, {0x1e85, 0x1e85}, {0x1e87, 0x1e87}, {0x1e89, 0x1e89},
392
    {0x1e8b, 0x1e8b}, {0x1e8d, 0x1e8d}, {0x1e8f, 0x1e8f}, {0x1e91, 0x1e91},
393
    {0x1e93, 0x1e93}, {0x1e95, 0x1e9b}, {0x1ea1, 0x1ea1}, {0x1ea3, 0x1ea3},
394
    {0x1ea5, 0x1ea5}, {0x1ea7, 0x1ea7}, {0x1ea9, 0x1ea9}, {0x1eab, 0x1eab},
395
    {0x1ead, 0x1ead}, {0x1eaf, 0x1eaf}, {0x1eb1, 0x1eb1}, {0x1eb3, 0x1eb3},
396
    {0x1eb5, 0x1eb5}, {0x1eb7, 0x1eb7}, {0x1eb9, 0x1eb9}, {0x1ebb, 0x1ebb},
397
    {0x1ebd, 0x1ebd}, {0x1ebf, 0x1ebf}, {0x1ec1, 0x1ec1}, {0x1ec3, 0x1ec3},
398
    {0x1ec5, 0x1ec5}, {0x1ec7, 0x1ec7}, {0x1ec9, 0x1ec9}, {0x1ecb, 0x1ecb},
399
    {0x1ecd, 0x1ecd}, {0x1ecf, 0x1ecf}, {0x1ed1, 0x1ed1}, {0x1ed3, 0x1ed3},
400
    {0x1ed5, 0x1ed5}, {0x1ed7, 0x1ed7}, {0x1ed9, 0x1ed9}, {0x1edb, 0x1edb},
401
    {0x1edd, 0x1edd}, {0x1edf, 0x1edf}, {0x1ee1, 0x1ee1}, {0x1ee3, 0x1ee3},
402
    {0x1ee5, 0x1ee5}, {0x1ee7, 0x1ee7}, {0x1ee9, 0x1ee9}, {0x1eeb, 0x1eeb},
403
    {0x1eed, 0x1eed}, {0x1eef, 0x1eef}, {0x1ef1, 0x1ef1}, {0x1ef3, 0x1ef3},
404
    {0x1ef5, 0x1ef5}, {0x1ef7, 0x1ef7}, {0x1ef9, 0x1ef9}, {0x1f00, 0x1f07},
405
    {0x1f10, 0x1f15}, {0x1f20, 0x1f27}, {0x1f30, 0x1f37}, {0x1f40, 0x1f45},
406
    {0x1f50, 0x1f57}, {0x1f60, 0x1f67}, {0x1f70, 0x1f7d}, {0x1f80, 0x1f87},
407
    {0x1f90, 0x1f97}, {0x1fa0, 0x1fa7}, {0x1fb0, 0x1fb4}, {0x1fb6, 0x1fb7},
408
    {0x1fbe, 0x1fbe}, {0x1fc2, 0x1fc4}, {0x1fc6, 0x1fc7}, {0x1fd0, 0x1fd3},
409
    {0x1fd6, 0x1fd7}, {0x1fe0, 0x1fe7}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ff7},
410
    {0x2071, 0x2071}, {0x207f, 0x207f}, {0x210a, 0x210a}, {0x210e, 0x210f},
411
    {0x2113, 0x2113}, {0x212f, 0x212f}, {0x2134, 0x2134}, {0x2139, 0x2139},
412
    {0x213d, 0x213d}, {0x2146, 0x2149}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17},
413
    {0xff41, 0xff5a} };
414
static const xmlChLRange xmlLlL[] = {{0x10428, 0x1044f}, {0x1d41a, 0x1d433},
415
    {0x1d44e, 0x1d454}, {0x1d456, 0x1d467}, {0x1d482, 0x1d49b},
416
    {0x1d4b6, 0x1d4b9}, {0x1d4bb, 0x1d4bb}, {0x1d4bd, 0x1d4c3},
417
    {0x1d4c5, 0x1d4cf}, {0x1d4ea, 0x1d503}, {0x1d51e, 0x1d537},
418
    {0x1d552, 0x1d56b}, {0x1d586, 0x1d59f}, {0x1d5ba, 0x1d5d3},
419
    {0x1d5ee, 0x1d607}, {0x1d622, 0x1d63b}, {0x1d656, 0x1d66f},
420
    {0x1d68a, 0x1d6a3}, {0x1d6c2, 0x1d6da}, {0x1d6dc, 0x1d6e1},
421
    {0x1d6fc, 0x1d714}, {0x1d716, 0x1d71b}, {0x1d736, 0x1d74e},
422
    {0x1d750, 0x1d755}, {0x1d770, 0x1d788}, {0x1d78a, 0x1d78f},
423
    {0x1d7aa, 0x1d7c2}, {0x1d7c4, 0x1d7c9} };
424
static const xmlChRangeGroup xmlLlG = {396,28,xmlLlS,xmlLlL};
425

426
static const xmlChSRange xmlLmS[] = {{0x2b0, 0x2c1}, {0x2c6, 0x2d1},
427
    {0x2e0, 0x2e4}, {0x2ee, 0x2ee}, {0x37a, 0x37a}, {0x559, 0x559},
428
    {0x640, 0x640}, {0x6e5, 0x6e6}, {0xe46, 0xe46}, {0xec6, 0xec6},
429
    {0x17d7, 0x17d7}, {0x1843, 0x1843}, {0x1d2c, 0x1d61}, {0x3005, 0x3005},
430
    {0x3031, 0x3035}, {0x303b, 0x303b}, {0x309d, 0x309e}, {0x30fc, 0x30fe},
431
    {0xff70, 0xff70}, {0xff9e, 0xff9f} };
432
static const xmlChRangeGroup xmlLmG = {20,0,xmlLmS,NULL};
433

434
static const xmlChSRange xmlLoS[] = {{0x1bb, 0x1bb}, {0x1c0, 0x1c3},
435
    {0x5d0, 0x5ea}, {0x5f0, 0x5f2}, {0x621, 0x63a}, {0x641, 0x64a},
436
    {0x66e, 0x66f}, {0x671, 0x6d3}, {0x6d5, 0x6d5}, {0x6ee, 0x6ef},
437
    {0x6fa, 0x6fc}, {0x6ff, 0x6ff}, {0x710, 0x710}, {0x712, 0x72f},
438
    {0x74d, 0x74f}, {0x780, 0x7a5}, {0x7b1, 0x7b1}, {0x904, 0x939},
439
    {0x93d, 0x93d}, {0x950, 0x950}, {0x958, 0x961}, {0x985, 0x98c},
440
    {0x98f, 0x990}, {0x993, 0x9a8}, {0x9aa, 0x9b0}, {0x9b2, 0x9b2},
441
    {0x9b6, 0x9b9}, {0x9bd, 0x9bd}, {0x9dc, 0x9dd}, {0x9df, 0x9e1},
442
    {0x9f0, 0x9f1}, {0xa05, 0xa0a}, {0xa0f, 0xa10}, {0xa13, 0xa28},
443
    {0xa2a, 0xa30}, {0xa32, 0xa33}, {0xa35, 0xa36}, {0xa38, 0xa39},
444
    {0xa59, 0xa5c}, {0xa5e, 0xa5e}, {0xa72, 0xa74}, {0xa85, 0xa8d},
445
    {0xa8f, 0xa91}, {0xa93, 0xaa8}, {0xaaa, 0xab0}, {0xab2, 0xab3},
446
    {0xab5, 0xab9}, {0xabd, 0xabd}, {0xad0, 0xad0}, {0xae0, 0xae1},
447
    {0xb05, 0xb0c}, {0xb0f, 0xb10}, {0xb13, 0xb28}, {0xb2a, 0xb30},
448
    {0xb32, 0xb33}, {0xb35, 0xb39}, {0xb3d, 0xb3d}, {0xb5c, 0xb5d},
449
    {0xb5f, 0xb61}, {0xb71, 0xb71}, {0xb83, 0xb83}, {0xb85, 0xb8a},
450
    {0xb8e, 0xb90}, {0xb92, 0xb95}, {0xb99, 0xb9a}, {0xb9c, 0xb9c},
451
    {0xb9e, 0xb9f}, {0xba3, 0xba4}, {0xba8, 0xbaa}, {0xbae, 0xbb5},
452
    {0xbb7, 0xbb9}, {0xc05, 0xc0c}, {0xc0e, 0xc10}, {0xc12, 0xc28},
453
    {0xc2a, 0xc33}, {0xc35, 0xc39}, {0xc60, 0xc61}, {0xc85, 0xc8c},
454
    {0xc8e, 0xc90}, {0xc92, 0xca8}, {0xcaa, 0xcb3}, {0xcb5, 0xcb9},
455
    {0xcbd, 0xcbd}, {0xcde, 0xcde}, {0xce0, 0xce1}, {0xd05, 0xd0c},
456
    {0xd0e, 0xd10}, {0xd12, 0xd28}, {0xd2a, 0xd39}, {0xd60, 0xd61},
457
    {0xd85, 0xd96}, {0xd9a, 0xdb1}, {0xdb3, 0xdbb}, {0xdbd, 0xdbd},
458
    {0xdc0, 0xdc6}, {0xe01, 0xe30}, {0xe32, 0xe33}, {0xe40, 0xe45},
459
    {0xe81, 0xe82}, {0xe84, 0xe84}, {0xe87, 0xe88}, {0xe8a, 0xe8a},
460
    {0xe8d, 0xe8d}, {0xe94, 0xe97}, {0xe99, 0xe9f}, {0xea1, 0xea3},
461
    {0xea5, 0xea5}, {0xea7, 0xea7}, {0xeaa, 0xeab}, {0xead, 0xeb0},
462
    {0xeb2, 0xeb3}, {0xebd, 0xebd}, {0xec0, 0xec4}, {0xedc, 0xedd},
463
    {0xf00, 0xf00}, {0xf40, 0xf47}, {0xf49, 0xf6a}, {0xf88, 0xf8b},
464
    {0x1000, 0x1021}, {0x1023, 0x1027}, {0x1029, 0x102a}, {0x1050, 0x1055},
465
    {0x10d0, 0x10f8}, {0x1100, 0x1159}, {0x115f, 0x11a2}, {0x11a8, 0x11f9},
466
    {0x1200, 0x1206}, {0x1208, 0x1246}, {0x1248, 0x1248}, {0x124a, 0x124d},
467
    {0x1250, 0x1256}, {0x1258, 0x1258}, {0x125a, 0x125d}, {0x1260, 0x1286},
468
    {0x1288, 0x1288}, {0x128a, 0x128d}, {0x1290, 0x12ae}, {0x12b0, 0x12b0},
469
    {0x12b2, 0x12b5}, {0x12b8, 0x12be}, {0x12c0, 0x12c0}, {0x12c2, 0x12c5},
470
    {0x12c8, 0x12ce}, {0x12d0, 0x12d6}, {0x12d8, 0x12ee}, {0x12f0, 0x130e},
471
    {0x1310, 0x1310}, {0x1312, 0x1315}, {0x1318, 0x131e}, {0x1320, 0x1346},
472
    {0x1348, 0x135a}, {0x13a0, 0x13f4}, {0x1401, 0x166c}, {0x166f, 0x1676},
473
    {0x1681, 0x169a}, {0x16a0, 0x16ea}, {0x1700, 0x170c}, {0x170e, 0x1711},
474
    {0x1720, 0x1731}, {0x1740, 0x1751}, {0x1760, 0x176c}, {0x176e, 0x1770},
475
    {0x1780, 0x17b3}, {0x17dc, 0x17dc}, {0x1820, 0x1842}, {0x1844, 0x1877},
476
    {0x1880, 0x18a8}, {0x1900, 0x191c}, {0x1950, 0x196d}, {0x1970, 0x1974},
477
    {0x2135, 0x2138}, {0x3006, 0x3006}, {0x303c, 0x303c}, {0x3041, 0x3096},
478
    {0x309f, 0x309f}, {0x30a1, 0x30fa}, {0x30ff, 0x30ff}, {0x3105, 0x312c},
479
    {0x3131, 0x318e}, {0x31a0, 0x31b7}, {0x31f0, 0x31ff}, {0x3400, 0x3400},
480
    {0x4db5, 0x4db5}, {0x4e00, 0x4e00}, {0x9fa5, 0x9fa5}, {0xa000, 0xa48c},
481
    {0xac00, 0xac00}, {0xd7a3, 0xd7a3}, {0xf900, 0xfa2d}, {0xfa30, 0xfa6a},
482
    {0xfb1d, 0xfb1d}, {0xfb1f, 0xfb28}, {0xfb2a, 0xfb36}, {0xfb38, 0xfb3c},
483
    {0xfb3e, 0xfb3e}, {0xfb40, 0xfb41}, {0xfb43, 0xfb44}, {0xfb46, 0xfbb1},
484
    {0xfbd3, 0xfd3d}, {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb},
485
    {0xfe70, 0xfe74}, {0xfe76, 0xfefc}, {0xff66, 0xff6f}, {0xff71, 0xff9d},
486
    {0xffa0, 0xffbe}, {0xffc2, 0xffc7}, {0xffca, 0xffcf}, {0xffd2, 0xffd7},
487
    {0xffda, 0xffdc} };
488
static const xmlChLRange xmlLoL[] = {{0x10000, 0x1000b}, {0x1000d, 0x10026},
489
    {0x10028, 0x1003a}, {0x1003c, 0x1003d}, {0x1003f, 0x1004d},
490
    {0x10050, 0x1005d}, {0x10080, 0x100fa}, {0x10300, 0x1031e},
491
    {0x10330, 0x10349}, {0x10380, 0x1039d}, {0x10450, 0x1049d},
492
    {0x10800, 0x10805}, {0x10808, 0x10808}, {0x1080a, 0x10835},
493
    {0x10837, 0x10838}, {0x1083c, 0x1083c}, {0x1083f, 0x1083f},
494
    {0x20000, 0x20000}, {0x2a6d6, 0x2a6d6}, {0x2f800, 0x2fa1d} };
495
static const xmlChRangeGroup xmlLoG = {211,20,xmlLoS,xmlLoL};
496

497
static const xmlChSRange xmlLtS[] = {{0x1c5, 0x1c5}, {0x1c8, 0x1c8},
498
    {0x1cb, 0x1cb}, {0x1f2, 0x1f2}, {0x1f88, 0x1f8f}, {0x1f98, 0x1f9f},
499
    {0x1fa8, 0x1faf}, {0x1fbc, 0x1fbc}, {0x1fcc, 0x1fcc}, {0x1ffc, 0x1ffc} };
500
static const xmlChRangeGroup xmlLtG = {10,0,xmlLtS,NULL};
501

502
static const xmlChSRange xmlLuS[] = {{0x41, 0x5a}, {0xc0, 0xd6},
503
    {0xd8, 0xde}, {0x100, 0x100}, {0x102, 0x102}, {0x104, 0x104},
504
    {0x106, 0x106}, {0x108, 0x108}, {0x10a, 0x10a}, {0x10c, 0x10c},
505
    {0x10e, 0x10e}, {0x110, 0x110}, {0x112, 0x112}, {0x114, 0x114},
506
    {0x116, 0x116}, {0x118, 0x118}, {0x11a, 0x11a}, {0x11c, 0x11c},
507
    {0x11e, 0x11e}, {0x120, 0x120}, {0x122, 0x122}, {0x124, 0x124},
508
    {0x126, 0x126}, {0x128, 0x128}, {0x12a, 0x12a}, {0x12c, 0x12c},
509
    {0x12e, 0x12e}, {0x130, 0x130}, {0x132, 0x132}, {0x134, 0x134},
510
    {0x136, 0x136}, {0x139, 0x139}, {0x13b, 0x13b}, {0x13d, 0x13d},
511
    {0x13f, 0x13f}, {0x141, 0x141}, {0x143, 0x143}, {0x145, 0x145},
512
    {0x147, 0x147}, {0x14a, 0x14a}, {0x14c, 0x14c}, {0x14e, 0x14e},
513
    {0x150, 0x150}, {0x152, 0x152}, {0x154, 0x154}, {0x156, 0x156},
514
    {0x158, 0x158}, {0x15a, 0x15a}, {0x15c, 0x15c}, {0x15e, 0x15e},
515
    {0x160, 0x160}, {0x162, 0x162}, {0x164, 0x164}, {0x166, 0x166},
516
    {0x168, 0x168}, {0x16a, 0x16a}, {0x16c, 0x16c}, {0x16e, 0x16e},
517
    {0x170, 0x170}, {0x172, 0x172}, {0x174, 0x174}, {0x176, 0x176},
518
    {0x178, 0x179}, {0x17b, 0x17b}, {0x17d, 0x17d}, {0x181, 0x182},
519
    {0x184, 0x184}, {0x186, 0x187}, {0x189, 0x18b}, {0x18e, 0x191},
520
    {0x193, 0x194}, {0x196, 0x198}, {0x19c, 0x19d}, {0x19f, 0x1a0},
521
    {0x1a2, 0x1a2}, {0x1a4, 0x1a4}, {0x1a6, 0x1a7}, {0x1a9, 0x1a9},
522
    {0x1ac, 0x1ac}, {0x1ae, 0x1af}, {0x1b1, 0x1b3}, {0x1b5, 0x1b5},
523
    {0x1b7, 0x1b8}, {0x1bc, 0x1bc}, {0x1c4, 0x1c4}, {0x1c7, 0x1c7},
524
    {0x1ca, 0x1ca}, {0x1cd, 0x1cd}, {0x1cf, 0x1cf}, {0x1d1, 0x1d1},
525
    {0x1d3, 0x1d3}, {0x1d5, 0x1d5}, {0x1d7, 0x1d7}, {0x1d9, 0x1d9},
526
    {0x1db, 0x1db}, {0x1de, 0x1de}, {0x1e0, 0x1e0}, {0x1e2, 0x1e2},
527
    {0x1e4, 0x1e4}, {0x1e6, 0x1e6}, {0x1e8, 0x1e8}, {0x1ea, 0x1ea},
528
    {0x1ec, 0x1ec}, {0x1ee, 0x1ee}, {0x1f1, 0x1f1}, {0x1f4, 0x1f4},
529
    {0x1f6, 0x1f8}, {0x1fa, 0x1fa}, {0x1fc, 0x1fc}, {0x1fe, 0x1fe},
530
    {0x200, 0x200}, {0x202, 0x202}, {0x204, 0x204}, {0x206, 0x206},
531
    {0x208, 0x208}, {0x20a, 0x20a}, {0x20c, 0x20c}, {0x20e, 0x20e},
532
    {0x210, 0x210}, {0x212, 0x212}, {0x214, 0x214}, {0x216, 0x216},
533
    {0x218, 0x218}, {0x21a, 0x21a}, {0x21c, 0x21c}, {0x21e, 0x21e},
534
    {0x220, 0x220}, {0x222, 0x222}, {0x224, 0x224}, {0x226, 0x226},
535
    {0x228, 0x228}, {0x22a, 0x22a}, {0x22c, 0x22c}, {0x22e, 0x22e},
536
    {0x230, 0x230}, {0x232, 0x232}, {0x386, 0x386}, {0x388, 0x38a},
537
    {0x38c, 0x38c}, {0x38e, 0x38f}, {0x391, 0x3a1}, {0x3a3, 0x3ab},
538
    {0x3d2, 0x3d4}, {0x3d8, 0x3d8}, {0x3da, 0x3da}, {0x3dc, 0x3dc},
539
    {0x3de, 0x3de}, {0x3e0, 0x3e0}, {0x3e2, 0x3e2}, {0x3e4, 0x3e4},
540
    {0x3e6, 0x3e6}, {0x3e8, 0x3e8}, {0x3ea, 0x3ea}, {0x3ec, 0x3ec},
541
    {0x3ee, 0x3ee}, {0x3f4, 0x3f4}, {0x3f7, 0x3f7}, {0x3f9, 0x3fa},
542
    {0x400, 0x42f}, {0x460, 0x460}, {0x462, 0x462}, {0x464, 0x464},
543
    {0x466, 0x466}, {0x468, 0x468}, {0x46a, 0x46a}, {0x46c, 0x46c},
544
    {0x46e, 0x46e}, {0x470, 0x470}, {0x472, 0x472}, {0x474, 0x474},
545
    {0x476, 0x476}, {0x478, 0x478}, {0x47a, 0x47a}, {0x47c, 0x47c},
546
    {0x47e, 0x47e}, {0x480, 0x480}, {0x48a, 0x48a}, {0x48c, 0x48c},
547
    {0x48e, 0x48e}, {0x490, 0x490}, {0x492, 0x492}, {0x494, 0x494},
548
    {0x496, 0x496}, {0x498, 0x498}, {0x49a, 0x49a}, {0x49c, 0x49c},
549
    {0x49e, 0x49e}, {0x4a0, 0x4a0}, {0x4a2, 0x4a2}, {0x4a4, 0x4a4},
550
    {0x4a6, 0x4a6}, {0x4a8, 0x4a8}, {0x4aa, 0x4aa}, {0x4ac, 0x4ac},
551
    {0x4ae, 0x4ae}, {0x4b0, 0x4b0}, {0x4b2, 0x4b2}, {0x4b4, 0x4b4},
552
    {0x4b6, 0x4b6}, {0x4b8, 0x4b8}, {0x4ba, 0x4ba}, {0x4bc, 0x4bc},
553
    {0x4be, 0x4be}, {0x4c0, 0x4c1}, {0x4c3, 0x4c3}, {0x4c5, 0x4c5},
554
    {0x4c7, 0x4c7}, {0x4c9, 0x4c9}, {0x4cb, 0x4cb}, {0x4cd, 0x4cd},
555
    {0x4d0, 0x4d0}, {0x4d2, 0x4d2}, {0x4d4, 0x4d4}, {0x4d6, 0x4d6},
556
    {0x4d8, 0x4d8}, {0x4da, 0x4da}, {0x4dc, 0x4dc}, {0x4de, 0x4de},
557
    {0x4e0, 0x4e0}, {0x4e2, 0x4e2}, {0x4e4, 0x4e4}, {0x4e6, 0x4e6},
558
    {0x4e8, 0x4e8}, {0x4ea, 0x4ea}, {0x4ec, 0x4ec}, {0x4ee, 0x4ee},
559
    {0x4f0, 0x4f0}, {0x4f2, 0x4f2}, {0x4f4, 0x4f4}, {0x4f8, 0x4f8},
560
    {0x500, 0x500}, {0x502, 0x502}, {0x504, 0x504}, {0x506, 0x506},
561
    {0x508, 0x508}, {0x50a, 0x50a}, {0x50c, 0x50c}, {0x50e, 0x50e},
562
    {0x531, 0x556}, {0x10a0, 0x10c5}, {0x1e00, 0x1e00}, {0x1e02, 0x1e02},
563
    {0x1e04, 0x1e04}, {0x1e06, 0x1e06}, {0x1e08, 0x1e08}, {0x1e0a, 0x1e0a},
564
    {0x1e0c, 0x1e0c}, {0x1e0e, 0x1e0e}, {0x1e10, 0x1e10}, {0x1e12, 0x1e12},
565
    {0x1e14, 0x1e14}, {0x1e16, 0x1e16}, {0x1e18, 0x1e18}, {0x1e1a, 0x1e1a},
566
    {0x1e1c, 0x1e1c}, {0x1e1e, 0x1e1e}, {0x1e20, 0x1e20}, {0x1e22, 0x1e22},
567
    {0x1e24, 0x1e24}, {0x1e26, 0x1e26}, {0x1e28, 0x1e28}, {0x1e2a, 0x1e2a},
568
    {0x1e2c, 0x1e2c}, {0x1e2e, 0x1e2e}, {0x1e30, 0x1e30}, {0x1e32, 0x1e32},
569
    {0x1e34, 0x1e34}, {0x1e36, 0x1e36}, {0x1e38, 0x1e38}, {0x1e3a, 0x1e3a},
570
    {0x1e3c, 0x1e3c}, {0x1e3e, 0x1e3e}, {0x1e40, 0x1e40}, {0x1e42, 0x1e42},
571
    {0x1e44, 0x1e44}, {0x1e46, 0x1e46}, {0x1e48, 0x1e48}, {0x1e4a, 0x1e4a},
572
    {0x1e4c, 0x1e4c}, {0x1e4e, 0x1e4e}, {0x1e50, 0x1e50}, {0x1e52, 0x1e52},
573
    {0x1e54, 0x1e54}, {0x1e56, 0x1e56}, {0x1e58, 0x1e58}, {0x1e5a, 0x1e5a},
574
    {0x1e5c, 0x1e5c}, {0x1e5e, 0x1e5e}, {0x1e60, 0x1e60}, {0x1e62, 0x1e62},
575
    {0x1e64, 0x1e64}, {0x1e66, 0x1e66}, {0x1e68, 0x1e68}, {0x1e6a, 0x1e6a},
576
    {0x1e6c, 0x1e6c}, {0x1e6e, 0x1e6e}, {0x1e70, 0x1e70}, {0x1e72, 0x1e72},
577
    {0x1e74, 0x1e74}, {0x1e76, 0x1e76}, {0x1e78, 0x1e78}, {0x1e7a, 0x1e7a},
578
    {0x1e7c, 0x1e7c}, {0x1e7e, 0x1e7e}, {0x1e80, 0x1e80}, {0x1e82, 0x1e82},
579
    {0x1e84, 0x1e84}, {0x1e86, 0x1e86}, {0x1e88, 0x1e88}, {0x1e8a, 0x1e8a},
580
    {0x1e8c, 0x1e8c}, {0x1e8e, 0x1e8e}, {0x1e90, 0x1e90}, {0x1e92, 0x1e92},
581
    {0x1e94, 0x1e94}, {0x1ea0, 0x1ea0}, {0x1ea2, 0x1ea2}, {0x1ea4, 0x1ea4},
582
    {0x1ea6, 0x1ea6}, {0x1ea8, 0x1ea8}, {0x1eaa, 0x1eaa}, {0x1eac, 0x1eac},
583
    {0x1eae, 0x1eae}, {0x1eb0, 0x1eb0}, {0x1eb2, 0x1eb2}, {0x1eb4, 0x1eb4},
584
    {0x1eb6, 0x1eb6}, {0x1eb8, 0x1eb8}, {0x1eba, 0x1eba}, {0x1ebc, 0x1ebc},
585
    {0x1ebe, 0x1ebe}, {0x1ec0, 0x1ec0}, {0x1ec2, 0x1ec2}, {0x1ec4, 0x1ec4},
586
    {0x1ec6, 0x1ec6}, {0x1ec8, 0x1ec8}, {0x1eca, 0x1eca}, {0x1ecc, 0x1ecc},
587
    {0x1ece, 0x1ece}, {0x1ed0, 0x1ed0}, {0x1ed2, 0x1ed2}, {0x1ed4, 0x1ed4},
588
    {0x1ed6, 0x1ed6}, {0x1ed8, 0x1ed8}, {0x1eda, 0x1eda}, {0x1edc, 0x1edc},
589
    {0x1ede, 0x1ede}, {0x1ee0, 0x1ee0}, {0x1ee2, 0x1ee2}, {0x1ee4, 0x1ee4},
590
    {0x1ee6, 0x1ee6}, {0x1ee8, 0x1ee8}, {0x1eea, 0x1eea}, {0x1eec, 0x1eec},
591
    {0x1eee, 0x1eee}, {0x1ef0, 0x1ef0}, {0x1ef2, 0x1ef2}, {0x1ef4, 0x1ef4},
592
    {0x1ef6, 0x1ef6}, {0x1ef8, 0x1ef8}, {0x1f08, 0x1f0f}, {0x1f18, 0x1f1d},
593
    {0x1f28, 0x1f2f}, {0x1f38, 0x1f3f}, {0x1f48, 0x1f4d}, {0x1f59, 0x1f59},
594
    {0x1f5b, 0x1f5b}, {0x1f5d, 0x1f5d}, {0x1f5f, 0x1f5f}, {0x1f68, 0x1f6f},
595
    {0x1fb8, 0x1fbb}, {0x1fc8, 0x1fcb}, {0x1fd8, 0x1fdb}, {0x1fe8, 0x1fec},
596
    {0x1ff8, 0x1ffb}, {0x2102, 0x2102}, {0x2107, 0x2107}, {0x210b, 0x210d},
597
    {0x2110, 0x2112}, {0x2115, 0x2115}, {0x2119, 0x211d}, {0x2124, 0x2124},
598
    {0x2126, 0x2126}, {0x2128, 0x2128}, {0x212a, 0x212d}, {0x2130, 0x2131},
599
    {0x2133, 0x2133}, {0x213e, 0x213f}, {0x2145, 0x2145}, {0xff21, 0xff3a} };
600
static const xmlChLRange xmlLuL[] = {{0x10400, 0x10427}, {0x1d400, 0x1d419},
601
    {0x1d434, 0x1d44d}, {0x1d468, 0x1d481}, {0x1d49c, 0x1d49c},
602
    {0x1d49e, 0x1d49f}, {0x1d4a2, 0x1d4a2}, {0x1d4a5, 0x1d4a6},
603
    {0x1d4a9, 0x1d4ac}, {0x1d4ae, 0x1d4b5}, {0x1d4d0, 0x1d4e9},
604
    {0x1d504, 0x1d505}, {0x1d507, 0x1d50a}, {0x1d50d, 0x1d514},
605
    {0x1d516, 0x1d51c}, {0x1d538, 0x1d539}, {0x1d53b, 0x1d53e},
606
    {0x1d540, 0x1d544}, {0x1d546, 0x1d546}, {0x1d54a, 0x1d550},
607
    {0x1d56c, 0x1d585}, {0x1d5a0, 0x1d5b9}, {0x1d5d4, 0x1d5ed},
608
    {0x1d608, 0x1d621}, {0x1d63c, 0x1d655}, {0x1d670, 0x1d689},
609
    {0x1d6a8, 0x1d6c0}, {0x1d6e2, 0x1d6fa}, {0x1d71c, 0x1d734},
610
    {0x1d756, 0x1d76e}, {0x1d790, 0x1d7a8} };
611
static const xmlChRangeGroup xmlLuG = {390,31,xmlLuS,xmlLuL};
612

613
static const xmlChSRange xmlMS[] = {{0x300, 0x357}, {0x35d, 0x36f},
614
    {0x483, 0x486}, {0x488, 0x489}, {0x591, 0x5a1}, {0x5a3, 0x5b9},
615
    {0x5bb, 0x5bd}, {0x5bf, 0x5bf}, {0x5c1, 0x5c2}, {0x5c4, 0x5c4},
616
    {0x610, 0x615}, {0x64b, 0x658}, {0x670, 0x670}, {0x6d6, 0x6dc},
617
    {0x6de, 0x6e4}, {0x6e7, 0x6e8}, {0x6ea, 0x6ed}, {0x711, 0x711},
618
    {0x730, 0x74a}, {0x7a6, 0x7b0}, {0x901, 0x903}, {0x93c, 0x93c},
619
    {0x93e, 0x94d}, {0x951, 0x954}, {0x962, 0x963}, {0x981, 0x983},
620
    {0x9bc, 0x9bc}, {0x9be, 0x9c4}, {0x9c7, 0x9c8}, {0x9cb, 0x9cd},
621
    {0x9d7, 0x9d7}, {0x9e2, 0x9e3}, {0xa01, 0xa03}, {0xa3c, 0xa3c},
622
    {0xa3e, 0xa42}, {0xa47, 0xa48}, {0xa4b, 0xa4d}, {0xa70, 0xa71},
623
    {0xa81, 0xa83}, {0xabc, 0xabc}, {0xabe, 0xac5}, {0xac7, 0xac9},
624
    {0xacb, 0xacd}, {0xae2, 0xae3}, {0xb01, 0xb03}, {0xb3c, 0xb3c},
625
    {0xb3e, 0xb43}, {0xb47, 0xb48}, {0xb4b, 0xb4d}, {0xb56, 0xb57},
626
    {0xb82, 0xb82}, {0xbbe, 0xbc2}, {0xbc6, 0xbc8}, {0xbca, 0xbcd},
627
    {0xbd7, 0xbd7}, {0xc01, 0xc03}, {0xc3e, 0xc44}, {0xc46, 0xc48},
628
    {0xc4a, 0xc4d}, {0xc55, 0xc56}, {0xc82, 0xc83}, {0xcbc, 0xcbc},
629
    {0xcbe, 0xcc4}, {0xcc6, 0xcc8}, {0xcca, 0xccd}, {0xcd5, 0xcd6},
630
    {0xd02, 0xd03}, {0xd3e, 0xd43}, {0xd46, 0xd48}, {0xd4a, 0xd4d},
631
    {0xd57, 0xd57}, {0xd82, 0xd83}, {0xdca, 0xdca}, {0xdcf, 0xdd4},
632
    {0xdd6, 0xdd6}, {0xdd8, 0xddf}, {0xdf2, 0xdf3}, {0xe31, 0xe31},
633
    {0xe34, 0xe3a}, {0xe47, 0xe4e}, {0xeb1, 0xeb1}, {0xeb4, 0xeb9},
634
    {0xebb, 0xebc}, {0xec8, 0xecd}, {0xf18, 0xf19}, {0xf35, 0xf35},
635
    {0xf37, 0xf37}, {0xf39, 0xf39}, {0xf3e, 0xf3f}, {0xf71, 0xf84},
636
    {0xf86, 0xf87}, {0xf90, 0xf97}, {0xf99, 0xfbc}, {0xfc6, 0xfc6},
637
    {0x102c, 0x1032}, {0x1036, 0x1039}, {0x1056, 0x1059}, {0x1712, 0x1714},
638
    {0x1732, 0x1734}, {0x1752, 0x1753}, {0x1772, 0x1773}, {0x17b6, 0x17d3},
639
    {0x17dd, 0x17dd}, {0x180b, 0x180d}, {0x18a9, 0x18a9}, {0x1920, 0x192b},
640
    {0x1930, 0x193b}, {0x20d0, 0x20ea}, {0x302a, 0x302f}, {0x3099, 0x309a},
641
    {0xfb1e, 0xfb1e}, {0xfe00, 0xfe0f}, {0xfe20, 0xfe23} };
642
static const xmlChLRange xmlML[] = {{0x1d165, 0x1d169}, {0x1d16d, 0x1d172},
643
    {0x1d17b, 0x1d182}, {0x1d185, 0x1d18b}, {0x1d1aa, 0x1d1ad},
644
    {0xe0100, 0xe01ef} };
645
static const xmlChRangeGroup xmlMG = {113,6,xmlMS,xmlML};
646

647
static const xmlChSRange xmlMcS[] = {{0x903, 0x903}, {0x93e, 0x940},
648
    {0x949, 0x94c}, {0x982, 0x983}, {0x9be, 0x9c0}, {0x9c7, 0x9c8},
649
    {0x9cb, 0x9cc}, {0x9d7, 0x9d7}, {0xa03, 0xa03}, {0xa3e, 0xa40},
650
    {0xa83, 0xa83}, {0xabe, 0xac0}, {0xac9, 0xac9}, {0xacb, 0xacc},
651
    {0xb02, 0xb03}, {0xb3e, 0xb3e}, {0xb40, 0xb40}, {0xb47, 0xb48},
652
    {0xb4b, 0xb4c}, {0xb57, 0xb57}, {0xbbe, 0xbbf}, {0xbc1, 0xbc2},
653
    {0xbc6, 0xbc8}, {0xbca, 0xbcc}, {0xbd7, 0xbd7}, {0xc01, 0xc03},
654
    {0xc41, 0xc44}, {0xc82, 0xc83}, {0xcbe, 0xcbe}, {0xcc0, 0xcc4},
655
    {0xcc7, 0xcc8}, {0xcca, 0xccb}, {0xcd5, 0xcd6}, {0xd02, 0xd03},
656
    {0xd3e, 0xd40}, {0xd46, 0xd48}, {0xd4a, 0xd4c}, {0xd57, 0xd57},
657
    {0xd82, 0xd83}, {0xdcf, 0xdd1}, {0xdd8, 0xddf}, {0xdf2, 0xdf3},
658
    {0xf3e, 0xf3f}, {0xf7f, 0xf7f}, {0x102c, 0x102c}, {0x1031, 0x1031},
659
    {0x1038, 0x1038}, {0x1056, 0x1057}, {0x17b6, 0x17b6}, {0x17be, 0x17c5},
660
    {0x17c7, 0x17c8}, {0x1923, 0x1926}, {0x1929, 0x192b}, {0x1930, 0x1931},
661
    {0x1933, 0x1938} };
662
static const xmlChLRange xmlMcL[] = {{0x1d165, 0x1d166}, {0x1d16d, 0x1d172} };
663
static const xmlChRangeGroup xmlMcG = {55,2,xmlMcS,xmlMcL};
664

665
static const xmlChSRange xmlMnS[] = {{0x300, 0x357}, {0x35d, 0x36f},
666
    {0x483, 0x486}, {0x591, 0x5a1}, {0x5a3, 0x5b9}, {0x5bb, 0x5bd},
667
    {0x5bf, 0x5bf}, {0x5c1, 0x5c2}, {0x5c4, 0x5c4}, {0x610, 0x615},
668
    {0x64b, 0x658}, {0x670, 0x670}, {0x6d6, 0x6dc}, {0x6df, 0x6e4},
669
    {0x6e7, 0x6e8}, {0x6ea, 0x6ed}, {0x711, 0x711}, {0x730, 0x74a},
670
    {0x7a6, 0x7b0}, {0x901, 0x902}, {0x93c, 0x93c}, {0x941, 0x948},
671
    {0x94d, 0x94d}, {0x951, 0x954}, {0x962, 0x963}, {0x981, 0x981},
672
    {0x9bc, 0x9bc}, {0x9c1, 0x9c4}, {0x9cd, 0x9cd}, {0x9e2, 0x9e3},
673
    {0xa01, 0xa02}, {0xa3c, 0xa3c}, {0xa41, 0xa42}, {0xa47, 0xa48},
674
    {0xa4b, 0xa4d}, {0xa70, 0xa71}, {0xa81, 0xa82}, {0xabc, 0xabc},
675
    {0xac1, 0xac5}, {0xac7, 0xac8}, {0xacd, 0xacd}, {0xae2, 0xae3},
676
    {0xb01, 0xb01}, {0xb3c, 0xb3c}, {0xb3f, 0xb3f}, {0xb41, 0xb43},
677
    {0xb4d, 0xb4d}, {0xb56, 0xb56}, {0xb82, 0xb82}, {0xbc0, 0xbc0},
678
    {0xbcd, 0xbcd}, {0xc3e, 0xc40}, {0xc46, 0xc48}, {0xc4a, 0xc4d},
679
    {0xc55, 0xc56}, {0xcbc, 0xcbc}, {0xcbf, 0xcbf}, {0xcc6, 0xcc6},
680
    {0xccc, 0xccd}, {0xd41, 0xd43}, {0xd4d, 0xd4d}, {0xdca, 0xdca},
681
    {0xdd2, 0xdd4}, {0xdd6, 0xdd6}, {0xe31, 0xe31}, {0xe34, 0xe3a},
682
    {0xe47, 0xe4e}, {0xeb1, 0xeb1}, {0xeb4, 0xeb9}, {0xebb, 0xebc},
683
    {0xec8, 0xecd}, {0xf18, 0xf19}, {0xf35, 0xf35}, {0xf37, 0xf37},
684
    {0xf39, 0xf39}, {0xf71, 0xf7e}, {0xf80, 0xf84}, {0xf86, 0xf87},
685
    {0xf90, 0xf97}, {0xf99, 0xfbc}, {0xfc6, 0xfc6}, {0x102d, 0x1030},
686
    {0x1032, 0x1032}, {0x1036, 0x1037}, {0x1039, 0x1039}, {0x1058, 0x1059},
687
    {0x1712, 0x1714}, {0x1732, 0x1734}, {0x1752, 0x1753}, {0x1772, 0x1773},
688
    {0x17b7, 0x17bd}, {0x17c6, 0x17c6}, {0x17c9, 0x17d3}, {0x17dd, 0x17dd},
689
    {0x180b, 0x180d}, {0x18a9, 0x18a9}, {0x1920, 0x1922}, {0x1927, 0x1928},
690
    {0x1932, 0x1932}, {0x1939, 0x193b}, {0x20d0, 0x20dc}, {0x20e1, 0x20e1},
691
    {0x20e5, 0x20ea}, {0x302a, 0x302f}, {0x3099, 0x309a}, {0xfb1e, 0xfb1e},
692
    {0xfe00, 0xfe0f}, {0xfe20, 0xfe23} };
693
static const xmlChLRange xmlMnL[] = {{0x1d167, 0x1d169}, {0x1d17b, 0x1d182},
694
    {0x1d185, 0x1d18b}, {0x1d1aa, 0x1d1ad}, {0xe0100, 0xe01ef} };
695
static const xmlChRangeGroup xmlMnG = {108,5,xmlMnS,xmlMnL};
696

697
static const xmlChSRange xmlNS[] = {{0x30, 0x39}, {0xb2, 0xb3},
698
    {0xb9, 0xb9}, {0xbc, 0xbe}, {0x660, 0x669}, {0x6f0, 0x6f9},
699
    {0x966, 0x96f}, {0x9e6, 0x9ef}, {0x9f4, 0x9f9}, {0xa66, 0xa6f},
700
    {0xae6, 0xaef}, {0xb66, 0xb6f}, {0xbe7, 0xbf2}, {0xc66, 0xc6f},
701
    {0xce6, 0xcef}, {0xd66, 0xd6f}, {0xe50, 0xe59}, {0xed0, 0xed9},
702
    {0xf20, 0xf33}, {0x1040, 0x1049}, {0x1369, 0x137c}, {0x16ee, 0x16f0},
703
    {0x17e0, 0x17e9}, {0x17f0, 0x17f9}, {0x1810, 0x1819}, {0x1946, 0x194f},
704
    {0x2070, 0x2070}, {0x2074, 0x2079}, {0x2080, 0x2089}, {0x2153, 0x2183},
705
    {0x2460, 0x249b}, {0x24ea, 0x24ff}, {0x2776, 0x2793}, {0x3007, 0x3007},
706
    {0x3021, 0x3029}, {0x3038, 0x303a}, {0x3192, 0x3195}, {0x3220, 0x3229},
707
    {0x3251, 0x325f}, {0x3280, 0x3289}, {0x32b1, 0x32bf}, {0xff10, 0xff19} };
708
static const xmlChLRange xmlNL[] = {{0x10107, 0x10133}, {0x10320, 0x10323},
709
    {0x1034a, 0x1034a}, {0x104a0, 0x104a9}, {0x1d7ce, 0x1d7ff} };
710
static const xmlChRangeGroup xmlNG = {42,5,xmlNS,xmlNL};
711

712
static const xmlChSRange xmlNdS[] = {{0x30, 0x39}, {0x660, 0x669},
713
    {0x6f0, 0x6f9}, {0x966, 0x96f}, {0x9e6, 0x9ef}, {0xa66, 0xa6f},
714
    {0xae6, 0xaef}, {0xb66, 0xb6f}, {0xbe7, 0xbef}, {0xc66, 0xc6f},
715
    {0xce6, 0xcef}, {0xd66, 0xd6f}, {0xe50, 0xe59}, {0xed0, 0xed9},
716
    {0xf20, 0xf29}, {0x1040, 0x1049}, {0x1369, 0x1371}, {0x17e0, 0x17e9},
717
    {0x1810, 0x1819}, {0x1946, 0x194f}, {0xff10, 0xff19} };
718
static const xmlChLRange xmlNdL[] = {{0x104a0, 0x104a9}, {0x1d7ce, 0x1d7ff} };
719
static const xmlChRangeGroup xmlNdG = {21,2,xmlNdS,xmlNdL};
720

721
static const xmlChSRange xmlNoS[] = {{0xb2, 0xb3}, {0xb9, 0xb9},
722
    {0xbc, 0xbe}, {0x9f4, 0x9f9}, {0xbf0, 0xbf2}, {0xf2a, 0xf33},
723
    {0x1372, 0x137c}, {0x17f0, 0x17f9}, {0x2070, 0x2070}, {0x2074, 0x2079},
724
    {0x2080, 0x2089}, {0x2153, 0x215f}, {0x2460, 0x249b}, {0x24ea, 0x24ff},
725
    {0x2776, 0x2793}, {0x3192, 0x3195}, {0x3220, 0x3229}, {0x3251, 0x325f},
726
    {0x3280, 0x3289}, {0x32b1, 0x32bf} };
727
static const xmlChLRange xmlNoL[] = {{0x10107, 0x10133}, {0x10320, 0x10323} };
728
static const xmlChRangeGroup xmlNoG = {20,2,xmlNoS,xmlNoL};
729

730
static const xmlChSRange xmlPS[] = {{0x21, 0x23}, {0x25, 0x2a},
731
    {0x2c, 0x2f}, {0x3a, 0x3b}, {0x3f, 0x40}, {0x5b, 0x5d}, {0x5f, 0x5f},
732
    {0x7b, 0x7b}, {0x7d, 0x7d}, {0xa1, 0xa1}, {0xab, 0xab}, {0xb7, 0xb7},
733
    {0xbb, 0xbb}, {0xbf, 0xbf}, {0x37e, 0x37e}, {0x387, 0x387},
734
    {0x55a, 0x55f}, {0x589, 0x58a}, {0x5be, 0x5be}, {0x5c0, 0x5c0},
735
    {0x5c3, 0x5c3}, {0x5f3, 0x5f4}, {0x60c, 0x60d}, {0x61b, 0x61b},
736
    {0x61f, 0x61f}, {0x66a, 0x66d}, {0x6d4, 0x6d4}, {0x700, 0x70d},
737
    {0x964, 0x965}, {0x970, 0x970}, {0xdf4, 0xdf4}, {0xe4f, 0xe4f},
738
    {0xe5a, 0xe5b}, {0xf04, 0xf12}, {0xf3a, 0xf3d}, {0xf85, 0xf85},
739
    {0x104a, 0x104f}, {0x10fb, 0x10fb}, {0x1361, 0x1368}, {0x166d, 0x166e},
740
    {0x169b, 0x169c}, {0x16eb, 0x16ed}, {0x1735, 0x1736}, {0x17d4, 0x17d6},
741
    {0x17d8, 0x17da}, {0x1800, 0x180a}, {0x1944, 0x1945}, {0x2010, 0x2027},
742
    {0x2030, 0x2043}, {0x2045, 0x2051}, {0x2053, 0x2054}, {0x2057, 0x2057},
743
    {0x207d, 0x207e}, {0x208d, 0x208e}, {0x2329, 0x232a}, {0x23b4, 0x23b6},
744
    {0x2768, 0x2775}, {0x27e6, 0x27eb}, {0x2983, 0x2998}, {0x29d8, 0x29db},
745
    {0x29fc, 0x29fd}, {0x3001, 0x3003}, {0x3008, 0x3011}, {0x3014, 0x301f},
746
    {0x3030, 0x3030}, {0x303d, 0x303d}, {0x30a0, 0x30a0}, {0x30fb, 0x30fb},
747
    {0xfd3e, 0xfd3f}, {0xfe30, 0xfe52}, {0xfe54, 0xfe61}, {0xfe63, 0xfe63},
748
    {0xfe68, 0xfe68}, {0xfe6a, 0xfe6b}, {0xff01, 0xff03}, {0xff05, 0xff0a},
749
    {0xff0c, 0xff0f}, {0xff1a, 0xff1b}, {0xff1f, 0xff20}, {0xff3b, 0xff3d},
750
    {0xff3f, 0xff3f}, {0xff5b, 0xff5b}, {0xff5d, 0xff5d}, {0xff5f, 0xff65} };
751
static const xmlChLRange xmlPL[] = {{0x10100, 0x10101}, {0x1039f, 0x1039f} };
752
static const xmlChRangeGroup xmlPG = {84,2,xmlPS,xmlPL};
753

754
static const xmlChSRange xmlPdS[] = {{0x2d, 0x2d}, {0x58a, 0x58a},
755
    {0x1806, 0x1806}, {0x2010, 0x2015}, {0x301c, 0x301c}, {0x3030, 0x3030},
756
    {0x30a0, 0x30a0}, {0xfe31, 0xfe32}, {0xfe58, 0xfe58}, {0xfe63, 0xfe63},
757
    {0xff0d, 0xff0d} };
758
static const xmlChRangeGroup xmlPdG = {11,0,xmlPdS,NULL};
759

760
static const xmlChSRange xmlPeS[] = {{0x29, 0x29}, {0x5d, 0x5d},
761
    {0x7d, 0x7d}, {0xf3b, 0xf3b}, {0xf3d, 0xf3d}, {0x169c, 0x169c},
762
    {0x2046, 0x2046}, {0x207e, 0x207e}, {0x208e, 0x208e}, {0x232a, 0x232a},
763
    {0x23b5, 0x23b5}, {0x2769, 0x2769}, {0x276b, 0x276b}, {0x276d, 0x276d},
764
    {0x276f, 0x276f}, {0x2771, 0x2771}, {0x2773, 0x2773}, {0x2775, 0x2775},
765
    {0x27e7, 0x27e7}, {0x27e9, 0x27e9}, {0x27eb, 0x27eb}, {0x2984, 0x2984},
766
    {0x2986, 0x2986}, {0x2988, 0x2988}, {0x298a, 0x298a}, {0x298c, 0x298c},
767
    {0x298e, 0x298e}, {0x2990, 0x2990}, {0x2992, 0x2992}, {0x2994, 0x2994},
768
    {0x2996, 0x2996}, {0x2998, 0x2998}, {0x29d9, 0x29d9}, {0x29db, 0x29db},
769
    {0x29fd, 0x29fd}, {0x3009, 0x3009}, {0x300b, 0x300b}, {0x300d, 0x300d},
770
    {0x300f, 0x300f}, {0x3011, 0x3011}, {0x3015, 0x3015}, {0x3017, 0x3017},
771
    {0x3019, 0x3019}, {0x301b, 0x301b}, {0x301e, 0x301f}, {0xfd3f, 0xfd3f},
772
    {0xfe36, 0xfe36}, {0xfe38, 0xfe38}, {0xfe3a, 0xfe3a}, {0xfe3c, 0xfe3c},
773
    {0xfe3e, 0xfe3e}, {0xfe40, 0xfe40}, {0xfe42, 0xfe42}, {0xfe44, 0xfe44},
774
    {0xfe48, 0xfe48}, {0xfe5a, 0xfe5a}, {0xfe5c, 0xfe5c}, {0xfe5e, 0xfe5e},
775
    {0xff09, 0xff09}, {0xff3d, 0xff3d}, {0xff5d, 0xff5d}, {0xff60, 0xff60},
776
    {0xff63, 0xff63} };
777
static const xmlChRangeGroup xmlPeG = {63,0,xmlPeS,NULL};
778

779
static const xmlChSRange xmlPoS[] = {{0x21, 0x23}, {0x25, 0x27},
780
    {0x2a, 0x2a}, {0x2c, 0x2c}, {0x2e, 0x2f}, {0x3a, 0x3b}, {0x3f, 0x40},
781
    {0x5c, 0x5c}, {0xa1, 0xa1}, {0xb7, 0xb7}, {0xbf, 0xbf}, {0x37e, 0x37e},
782
    {0x387, 0x387}, {0x55a, 0x55f}, {0x589, 0x589}, {0x5be, 0x5be},
783
    {0x5c0, 0x5c0}, {0x5c3, 0x5c3}, {0x5f3, 0x5f4}, {0x60c, 0x60d},
784
    {0x61b, 0x61b}, {0x61f, 0x61f}, {0x66a, 0x66d}, {0x6d4, 0x6d4},
785
    {0x700, 0x70d}, {0x964, 0x965}, {0x970, 0x970}, {0xdf4, 0xdf4},
786
    {0xe4f, 0xe4f}, {0xe5a, 0xe5b}, {0xf04, 0xf12}, {0xf85, 0xf85},
787
    {0x104a, 0x104f}, {0x10fb, 0x10fb}, {0x1361, 0x1368}, {0x166d, 0x166e},
788
    {0x16eb, 0x16ed}, {0x1735, 0x1736}, {0x17d4, 0x17d6}, {0x17d8, 0x17da},
789
    {0x1800, 0x1805}, {0x1807, 0x180a}, {0x1944, 0x1945}, {0x2016, 0x2017},
790
    {0x2020, 0x2027}, {0x2030, 0x2038}, {0x203b, 0x203e}, {0x2041, 0x2043},
791
    {0x2047, 0x2051}, {0x2053, 0x2053}, {0x2057, 0x2057}, {0x23b6, 0x23b6},
792
    {0x3001, 0x3003}, {0x303d, 0x303d}, {0xfe30, 0xfe30}, {0xfe45, 0xfe46},
793
    {0xfe49, 0xfe4c}, {0xfe50, 0xfe52}, {0xfe54, 0xfe57}, {0xfe5f, 0xfe61},
794
    {0xfe68, 0xfe68}, {0xfe6a, 0xfe6b}, {0xff01, 0xff03}, {0xff05, 0xff07},
795
    {0xff0a, 0xff0a}, {0xff0c, 0xff0c}, {0xff0e, 0xff0f}, {0xff1a, 0xff1b},
796
    {0xff1f, 0xff20}, {0xff3c, 0xff3c}, {0xff61, 0xff61}, {0xff64, 0xff64} };
797
static const xmlChLRange xmlPoL[] = {{0x10100, 0x10101}, {0x1039f, 0x1039f} };
798
static const xmlChRangeGroup xmlPoG = {72,2,xmlPoS,xmlPoL};
799

800
static const xmlChSRange xmlPsS[] = {{0x28, 0x28}, {0x5b, 0x5b},
801
    {0x7b, 0x7b}, {0xf3a, 0xf3a}, {0xf3c, 0xf3c}, {0x169b, 0x169b},
802
    {0x201a, 0x201a}, {0x201e, 0x201e}, {0x2045, 0x2045}, {0x207d, 0x207d},
803
    {0x208d, 0x208d}, {0x2329, 0x2329}, {0x23b4, 0x23b4}, {0x2768, 0x2768},
804
    {0x276a, 0x276a}, {0x276c, 0x276c}, {0x276e, 0x276e}, {0x2770, 0x2770},
805
    {0x2772, 0x2772}, {0x2774, 0x2774}, {0x27e6, 0x27e6}, {0x27e8, 0x27e8},
806
    {0x27ea, 0x27ea}, {0x2983, 0x2983}, {0x2985, 0x2985}, {0x2987, 0x2987},
807
    {0x2989, 0x2989}, {0x298b, 0x298b}, {0x298d, 0x298d}, {0x298f, 0x298f},
808
    {0x2991, 0x2991}, {0x2993, 0x2993}, {0x2995, 0x2995}, {0x2997, 0x2997},
809
    {0x29d8, 0x29d8}, {0x29da, 0x29da}, {0x29fc, 0x29fc}, {0x3008, 0x3008},
810
    {0x300a, 0x300a}, {0x300c, 0x300c}, {0x300e, 0x300e}, {0x3010, 0x3010},
811
    {0x3014, 0x3014}, {0x3016, 0x3016}, {0x3018, 0x3018}, {0x301a, 0x301a},
812
    {0x301d, 0x301d}, {0xfd3e, 0xfd3e}, {0xfe35, 0xfe35}, {0xfe37, 0xfe37},
813
    {0xfe39, 0xfe39}, {0xfe3b, 0xfe3b}, {0xfe3d, 0xfe3d}, {0xfe3f, 0xfe3f},
814
    {0xfe41, 0xfe41}, {0xfe43, 0xfe43}, {0xfe47, 0xfe47}, {0xfe59, 0xfe59},
815
    {0xfe5b, 0xfe5b}, {0xfe5d, 0xfe5d}, {0xff08, 0xff08}, {0xff3b, 0xff3b},
816
    {0xff5b, 0xff5b}, {0xff5f, 0xff5f}, {0xff62, 0xff62} };
817
static const xmlChRangeGroup xmlPsG = {65,0,xmlPsS,NULL};
818

819
static const xmlChSRange xmlSS[] = {{0x24, 0x24}, {0x2b, 0x2b},
820
    {0x3c, 0x3e}, {0x5e, 0x5e}, {0x60, 0x60}, {0x7c, 0x7c}, {0x7e, 0x7e},
821
    {0xa2, 0xa9}, {0xac, 0xac}, {0xae, 0xb1}, {0xb4, 0xb4}, {0xb6, 0xb6},
822
    {0xb8, 0xb8}, {0xd7, 0xd7}, {0xf7, 0xf7}, {0x2c2, 0x2c5},
823
    {0x2d2, 0x2df}, {0x2e5, 0x2ed}, {0x2ef, 0x2ff}, {0x374, 0x375},
824
    {0x384, 0x385}, {0x3f6, 0x3f6}, {0x482, 0x482}, {0x60e, 0x60f},
825
    {0x6e9, 0x6e9}, {0x6fd, 0x6fe}, {0x9f2, 0x9f3}, {0x9fa, 0x9fa},
826
    {0xaf1, 0xaf1}, {0xb70, 0xb70}, {0xbf3, 0xbfa}, {0xe3f, 0xe3f},
827
    {0xf01, 0xf03}, {0xf13, 0xf17}, {0xf1a, 0xf1f}, {0xf34, 0xf34},
828
    {0xf36, 0xf36}, {0xf38, 0xf38}, {0xfbe, 0xfc5}, {0xfc7, 0xfcc},
829
    {0xfcf, 0xfcf}, {0x17db, 0x17db}, {0x1940, 0x1940}, {0x19e0, 0x19ff},
830
    {0x1fbd, 0x1fbd}, {0x1fbf, 0x1fc1}, {0x1fcd, 0x1fcf}, {0x1fdd, 0x1fdf},
831
    {0x1fed, 0x1fef}, {0x1ffd, 0x1ffe}, {0x2044, 0x2044}, {0x2052, 0x2052},
832
    {0x207a, 0x207c}, {0x208a, 0x208c}, {0x20a0, 0x20b1}, {0x2100, 0x2101},
833
    {0x2103, 0x2106}, {0x2108, 0x2109}, {0x2114, 0x2114}, {0x2116, 0x2118},
834
    {0x211e, 0x2123}, {0x2125, 0x2125}, {0x2127, 0x2127}, {0x2129, 0x2129},
835
    {0x212e, 0x212e}, {0x2132, 0x2132}, {0x213a, 0x213b}, {0x2140, 0x2144},
836
    {0x214a, 0x214b}, {0x2190, 0x2328}, {0x232b, 0x23b3}, {0x23b7, 0x23d0},
837
    {0x2400, 0x2426}, {0x2440, 0x244a}, {0x249c, 0x24e9}, {0x2500, 0x2617},
838
    {0x2619, 0x267d}, {0x2680, 0x2691}, {0x26a0, 0x26a1}, {0x2701, 0x2704},
839
    {0x2706, 0x2709}, {0x270c, 0x2727}, {0x2729, 0x274b}, {0x274d, 0x274d},
840
    {0x274f, 0x2752}, {0x2756, 0x2756}, {0x2758, 0x275e}, {0x2761, 0x2767},
841
    {0x2794, 0x2794}, {0x2798, 0x27af}, {0x27b1, 0x27be}, {0x27d0, 0x27e5},
842
    {0x27f0, 0x2982}, {0x2999, 0x29d7}, {0x29dc, 0x29fb}, {0x29fe, 0x2b0d},
843
    {0x2e80, 0x2e99}, {0x2e9b, 0x2ef3}, {0x2f00, 0x2fd5}, {0x2ff0, 0x2ffb},
844
    {0x3004, 0x3004}, {0x3012, 0x3013}, {0x3020, 0x3020}, {0x3036, 0x3037},
845
    {0x303e, 0x303f}, {0x309b, 0x309c}, {0x3190, 0x3191}, {0x3196, 0x319f},
846
    {0x3200, 0x321e}, {0x322a, 0x3243}, {0x3250, 0x3250}, {0x3260, 0x327d},
847
    {0x327f, 0x327f}, {0x328a, 0x32b0}, {0x32c0, 0x32fe}, {0x3300, 0x33ff},
848
    {0x4dc0, 0x4dff}, {0xa490, 0xa4c6}, {0xfb29, 0xfb29}, {0xfdfc, 0xfdfd},
849
    {0xfe62, 0xfe62}, {0xfe64, 0xfe66}, {0xfe69, 0xfe69}, {0xff04, 0xff04},
850
    {0xff0b, 0xff0b}, {0xff1c, 0xff1e}, {0xff3e, 0xff3e}, {0xff40, 0xff40},
851
    {0xff5c, 0xff5c}, {0xff5e, 0xff5e}, {0xffe0, 0xffe6}, {0xffe8, 0xffee},
852
    {0xfffc, 0xfffd} };
853
static const xmlChLRange xmlSL[] = {{0x10102, 0x10102}, {0x10137, 0x1013f},
854
    {0x1d000, 0x1d0f5}, {0x1d100, 0x1d126}, {0x1d12a, 0x1d164},
855
    {0x1d16a, 0x1d16c}, {0x1d183, 0x1d184}, {0x1d18c, 0x1d1a9},
856
    {0x1d1ae, 0x1d1dd}, {0x1d300, 0x1d356}, {0x1d6c1, 0x1d6c1},
857
    {0x1d6db, 0x1d6db}, {0x1d6fb, 0x1d6fb}, {0x1d715, 0x1d715},
858
    {0x1d735, 0x1d735}, {0x1d74f, 0x1d74f}, {0x1d76f, 0x1d76f},
859
    {0x1d789, 0x1d789}, {0x1d7a9, 0x1d7a9}, {0x1d7c3, 0x1d7c3} };
860
static const xmlChRangeGroup xmlSG = {133,20,xmlSS,xmlSL};
861

862
static const xmlChSRange xmlScS[] = {{0x24, 0x24}, {0xa2, 0xa5},
863
    {0x9f2, 0x9f3}, {0xaf1, 0xaf1}, {0xbf9, 0xbf9}, {0xe3f, 0xe3f},
864
    {0x17db, 0x17db}, {0x20a0, 0x20b1}, {0xfdfc, 0xfdfc}, {0xfe69, 0xfe69},
865
    {0xff04, 0xff04}, {0xffe0, 0xffe1}, {0xffe5, 0xffe6} };
866
static const xmlChRangeGroup xmlScG = {13,0,xmlScS,NULL};
867

868
static const xmlChSRange xmlSkS[] = {{0x5e, 0x5e}, {0x60, 0x60},
869
    {0xa8, 0xa8}, {0xaf, 0xaf}, {0xb4, 0xb4}, {0xb8, 0xb8}, {0x2c2, 0x2c5},
870
    {0x2d2, 0x2df}, {0x2e5, 0x2ed}, {0x2ef, 0x2ff}, {0x374, 0x375},
871
    {0x384, 0x385}, {0x1fbd, 0x1fbd}, {0x1fbf, 0x1fc1}, {0x1fcd, 0x1fcf},
872
    {0x1fdd, 0x1fdf}, {0x1fed, 0x1fef}, {0x1ffd, 0x1ffe}, {0x309b, 0x309c},
873
    {0xff3e, 0xff3e}, {0xff40, 0xff40}, {0xffe3, 0xffe3} };
874
static const xmlChRangeGroup xmlSkG = {22,0,xmlSkS,NULL};
875

876
static const xmlChSRange xmlSmS[] = {{0x2b, 0x2b}, {0x3c, 0x3e},
877
    {0x7c, 0x7c}, {0x7e, 0x7e}, {0xac, 0xac}, {0xb1, 0xb1}, {0xd7, 0xd7},
878
    {0xf7, 0xf7}, {0x3f6, 0x3f6}, {0x2044, 0x2044}, {0x2052, 0x2052},
879
    {0x207a, 0x207c}, {0x208a, 0x208c}, {0x2140, 0x2144}, {0x214b, 0x214b},
880
    {0x2190, 0x2194}, {0x219a, 0x219b}, {0x21a0, 0x21a0}, {0x21a3, 0x21a3},
881
    {0x21a6, 0x21a6}, {0x21ae, 0x21ae}, {0x21ce, 0x21cf}, {0x21d2, 0x21d2},
882
    {0x21d4, 0x21d4}, {0x21f4, 0x22ff}, {0x2308, 0x230b}, {0x2320, 0x2321},
883
    {0x237c, 0x237c}, {0x239b, 0x23b3}, {0x25b7, 0x25b7}, {0x25c1, 0x25c1},
884
    {0x25f8, 0x25ff}, {0x266f, 0x266f}, {0x27d0, 0x27e5}, {0x27f0, 0x27ff},
885
    {0x2900, 0x2982}, {0x2999, 0x29d7}, {0x29dc, 0x29fb}, {0x29fe, 0x2aff},
886
    {0xfb29, 0xfb29}, {0xfe62, 0xfe62}, {0xfe64, 0xfe66}, {0xff0b, 0xff0b},
887
    {0xff1c, 0xff1e}, {0xff5c, 0xff5c}, {0xff5e, 0xff5e}, {0xffe2, 0xffe2},
888
    {0xffe9, 0xffec} };
889
static const xmlChLRange xmlSmL[] = {{0x1d6c1, 0x1d6c1}, {0x1d6db, 0x1d6db},
890
    {0x1d6fb, 0x1d6fb}, {0x1d715, 0x1d715}, {0x1d735, 0x1d735},
891
    {0x1d74f, 0x1d74f}, {0x1d76f, 0x1d76f}, {0x1d789, 0x1d789},
892
    {0x1d7a9, 0x1d7a9}, {0x1d7c3, 0x1d7c3} };
893
static const xmlChRangeGroup xmlSmG = {48,10,xmlSmS,xmlSmL};
894

895
static const xmlChSRange xmlSoS[] = {{0xa6, 0xa7}, {0xa9, 0xa9},
896
    {0xae, 0xae}, {0xb0, 0xb0}, {0xb6, 0xb6}, {0x482, 0x482},
897
    {0x60e, 0x60f}, {0x6e9, 0x6e9}, {0x6fd, 0x6fe}, {0x9fa, 0x9fa},
898
    {0xb70, 0xb70}, {0xbf3, 0xbf8}, {0xbfa, 0xbfa}, {0xf01, 0xf03},
899
    {0xf13, 0xf17}, {0xf1a, 0xf1f}, {0xf34, 0xf34}, {0xf36, 0xf36},
900
    {0xf38, 0xf38}, {0xfbe, 0xfc5}, {0xfc7, 0xfcc}, {0xfcf, 0xfcf},
901
    {0x1940, 0x1940}, {0x19e0, 0x19ff}, {0x2100, 0x2101}, {0x2103, 0x2106},
902
    {0x2108, 0x2109}, {0x2114, 0x2114}, {0x2116, 0x2118}, {0x211e, 0x2123},
903
    {0x2125, 0x2125}, {0x2127, 0x2127}, {0x2129, 0x2129}, {0x212e, 0x212e},
904
    {0x2132, 0x2132}, {0x213a, 0x213b}, {0x214a, 0x214a}, {0x2195, 0x2199},
905
    {0x219c, 0x219f}, {0x21a1, 0x21a2}, {0x21a4, 0x21a5}, {0x21a7, 0x21ad},
906
    {0x21af, 0x21cd}, {0x21d0, 0x21d1}, {0x21d3, 0x21d3}, {0x21d5, 0x21f3},
907
    {0x2300, 0x2307}, {0x230c, 0x231f}, {0x2322, 0x2328}, {0x232b, 0x237b},
908
    {0x237d, 0x239a}, {0x23b7, 0x23d0}, {0x2400, 0x2426}, {0x2440, 0x244a},
909
    {0x249c, 0x24e9}, {0x2500, 0x25b6}, {0x25b8, 0x25c0}, {0x25c2, 0x25f7},
910
    {0x2600, 0x2617}, {0x2619, 0x266e}, {0x2670, 0x267d}, {0x2680, 0x2691},
911
    {0x26a0, 0x26a1}, {0x2701, 0x2704}, {0x2706, 0x2709}, {0x270c, 0x2727},
912
    {0x2729, 0x274b}, {0x274d, 0x274d}, {0x274f, 0x2752}, {0x2756, 0x2756},
913
    {0x2758, 0x275e}, {0x2761, 0x2767}, {0x2794, 0x2794}, {0x2798, 0x27af},
914
    {0x27b1, 0x27be}, {0x2800, 0x28ff}, {0x2b00, 0x2b0d}, {0x2e80, 0x2e99},
915
    {0x2e9b, 0x2ef3}, {0x2f00, 0x2fd5}, {0x2ff0, 0x2ffb}, {0x3004, 0x3004},
916
    {0x3012, 0x3013}, {0x3020, 0x3020}, {0x3036, 0x3037}, {0x303e, 0x303f},
917
    {0x3190, 0x3191}, {0x3196, 0x319f}, {0x3200, 0x321e}, {0x322a, 0x3243},
918
    {0x3250, 0x3250}, {0x3260, 0x327d}, {0x327f, 0x327f}, {0x328a, 0x32b0},
919
    {0x32c0, 0x32fe}, {0x3300, 0x33ff}, {0x4dc0, 0x4dff}, {0xa490, 0xa4c6},
920
    {0xfdfd, 0xfdfd}, {0xffe4, 0xffe4}, {0xffe8, 0xffe8}, {0xffed, 0xffee},
921
    {0xfffc, 0xfffd} };
922
static const xmlChLRange xmlSoL[] = {{0x10102, 0x10102}, {0x10137, 0x1013f},
923
    {0x1d000, 0x1d0f5}, {0x1d100, 0x1d126}, {0x1d12a, 0x1d164},
924
    {0x1d16a, 0x1d16c}, {0x1d183, 0x1d184}, {0x1d18c, 0x1d1a9},
925
    {0x1d1ae, 0x1d1dd}, {0x1d300, 0x1d356} };
926
static const xmlChRangeGroup xmlSoG = {103,10,xmlSoS,xmlSoL};
927

928
static const xmlChSRange xmlZS[] = {{0x20, 0x20}, {0xa0, 0xa0},
929
    {0x1680, 0x1680}, {0x180e, 0x180e}, {0x2000, 0x200a}, {0x2028, 0x2029},
930
    {0x202f, 0x202f}, {0x205f, 0x205f}, {0x3000, 0x3000} };
931
static const xmlChRangeGroup xmlZG = {9,0,xmlZS,NULL};
932

933
static const xmlUnicodeNameTable xmlUnicodeBlockTbl = {xmlUnicodeBlocks, 128};
934
static const xmlUnicodeNameTable xmlUnicodeCatTbl = {xmlUnicodeCats, 36};
935

936
/**
937
 * xmlUnicodeLookup:
938
 * @tptr: pointer to the name table
939
 * @name: name to be found
940
 *
941
 * binary table lookup for user-supplied name
942
 *
943
 * Returns pointer to range function if found, otherwise NULL
944
 */
945
static xmlIntFunc
946
*xmlUnicodeLookup(const xmlUnicodeNameTable *tptr, const char *tname) {
947
    int low, high, mid, cmp;
948
    const xmlUnicodeRange *sptr;
949

950
    if ((tptr == NULL) || (tname == NULL)) return(NULL);
951

952
    low = 0;
953
    high = tptr->numentries - 1;
954
    sptr = tptr->table;
955
    while (low <= high) {
956
	mid = (low + high) / 2;
957
	if ((cmp=strcmp(tname, sptr[mid].rangename)) == 0)
958
	    return (sptr[mid].func);
959
	if (cmp < 0)
960
	    high = mid - 1;
961
	else
962
	    low = mid + 1;
963
    }
964
    return (NULL);
965
}
966

967
/**
968
 * xmlUCSIsAegeanNumbers:
969
 * @code: UCS code point
970
 *
971
 * Check whether the character is part of AegeanNumbers UCS Block
972
 *
973
 * Returns 1 if true 0 otherwise
974
 */
975
int
976
xmlUCSIsAegeanNumbers(int code) {
977
    return(((code >= 0x10100) && (code <= 0x1013F)));
978
}
979

980
/**
981
 * xmlUCSIsAlphabeticPresentationForms:
982
 * @code: UCS code point
983
 *
984
 * Check whether the character is part of AlphabeticPresentationForms UCS Block
985
 *
986
 * Returns 1 if true 0 otherwise
987
 */
988
int
989
xmlUCSIsAlphabeticPresentationForms(int code) {
990
    return(((code >= 0xFB00) && (code <= 0xFB4F)));
991
}
992

993
/**
994
 * xmlUCSIsArabic:
995
 * @code: UCS code point
996
 *
997
 * Check whether the character is part of Arabic UCS Block
998
 *
999
 * Returns 1 if true 0 otherwise
1000
 */
1001
int
1002
xmlUCSIsArabic(int code) {
1003
    return(((code >= 0x0600) && (code <= 0x06FF)));
1004
}
1005

1006
/**
1007
 * xmlUCSIsArabicPresentationFormsA:
1008
 * @code: UCS code point
1009
 *
1010
 * Check whether the character is part of ArabicPresentationForms-A UCS Block
1011
 *
1012
 * Returns 1 if true 0 otherwise
1013
 */
1014
int
1015
xmlUCSIsArabicPresentationFormsA(int code) {
1016
    return(((code >= 0xFB50) && (code <= 0xFDFF)));
1017
}
1018

1019
/**
1020
 * xmlUCSIsArabicPresentationFormsB:
1021
 * @code: UCS code point
1022
 *
1023
 * Check whether the character is part of ArabicPresentationForms-B UCS Block
1024
 *
1025
 * Returns 1 if true 0 otherwise
1026
 */
1027
int
1028
xmlUCSIsArabicPresentationFormsB(int code) {
1029
    return(((code >= 0xFE70) && (code <= 0xFEFF)));
1030
}
1031

1032
/**
1033
 * xmlUCSIsArmenian:
1034
 * @code: UCS code point
1035
 *
1036
 * Check whether the character is part of Armenian UCS Block
1037
 *
1038
 * Returns 1 if true 0 otherwise
1039
 */
1040
int
1041
xmlUCSIsArmenian(int code) {
1042
    return(((code >= 0x0530) && (code <= 0x058F)));
1043
}
1044

1045
/**
1046
 * xmlUCSIsArrows:
1047
 * @code: UCS code point
1048
 *
1049
 * Check whether the character is part of Arrows UCS Block
1050
 *
1051
 * Returns 1 if true 0 otherwise
1052
 */
1053
int
1054
xmlUCSIsArrows(int code) {
1055
    return(((code >= 0x2190) && (code <= 0x21FF)));
1056
}
1057

1058
/**
1059
 * xmlUCSIsBasicLatin:
1060
 * @code: UCS code point
1061
 *
1062
 * Check whether the character is part of BasicLatin UCS Block
1063
 *
1064
 * Returns 1 if true 0 otherwise
1065
 */
1066
int
1067
xmlUCSIsBasicLatin(int code) {
1068
    return(((code >= 0x0000) && (code <= 0x007F)));
1069
}
1070

1071
/**
1072
 * xmlUCSIsBengali:
1073
 * @code: UCS code point
1074
 *
1075
 * Check whether the character is part of Bengali UCS Block
1076
 *
1077
 * Returns 1 if true 0 otherwise
1078
 */
1079
int
1080
xmlUCSIsBengali(int code) {
1081
    return(((code >= 0x0980) && (code <= 0x09FF)));
1082
}
1083

1084
/**
1085
 * xmlUCSIsBlockElements:
1086
 * @code: UCS code point
1087
 *
1088
 * Check whether the character is part of BlockElements UCS Block
1089
 *
1090
 * Returns 1 if true 0 otherwise
1091
 */
1092
int
1093
xmlUCSIsBlockElements(int code) {
1094
    return(((code >= 0x2580) && (code <= 0x259F)));
1095
}
1096

1097
/**
1098
 * xmlUCSIsBopomofo:
1099
 * @code: UCS code point
1100
 *
1101
 * Check whether the character is part of Bopomofo UCS Block
1102
 *
1103
 * Returns 1 if true 0 otherwise
1104
 */
1105
int
1106
xmlUCSIsBopomofo(int code) {
1107
    return(((code >= 0x3100) && (code <= 0x312F)));
1108
}
1109

1110
/**
1111
 * xmlUCSIsBopomofoExtended:
1112
 * @code: UCS code point
1113
 *
1114
 * Check whether the character is part of BopomofoExtended UCS Block
1115
 *
1116
 * Returns 1 if true 0 otherwise
1117
 */
1118
int
1119
xmlUCSIsBopomofoExtended(int code) {
1120
    return(((code >= 0x31A0) && (code <= 0x31BF)));
1121
}
1122

1123
/**
1124
 * xmlUCSIsBoxDrawing:
1125
 * @code: UCS code point
1126
 *
1127
 * Check whether the character is part of BoxDrawing UCS Block
1128
 *
1129
 * Returns 1 if true 0 otherwise
1130
 */
1131
int
1132
xmlUCSIsBoxDrawing(int code) {
1133
    return(((code >= 0x2500) && (code <= 0x257F)));
1134
}
1135

1136
/**
1137
 * xmlUCSIsBraillePatterns:
1138
 * @code: UCS code point
1139
 *
1140
 * Check whether the character is part of BraillePatterns UCS Block
1141
 *
1142
 * Returns 1 if true 0 otherwise
1143
 */
1144
int
1145
xmlUCSIsBraillePatterns(int code) {
1146
    return(((code >= 0x2800) && (code <= 0x28FF)));
1147
}
1148

1149
/**
1150
 * xmlUCSIsBuhid:
1151
 * @code: UCS code point
1152
 *
1153
 * Check whether the character is part of Buhid UCS Block
1154
 *
1155
 * Returns 1 if true 0 otherwise
1156
 */
1157
int
1158
xmlUCSIsBuhid(int code) {
1159
    return(((code >= 0x1740) && (code <= 0x175F)));
1160
}
1161

1162
/**
1163
 * xmlUCSIsByzantineMusicalSymbols:
1164
 * @code: UCS code point
1165
 *
1166
 * Check whether the character is part of ByzantineMusicalSymbols UCS Block
1167
 *
1168
 * Returns 1 if true 0 otherwise
1169
 */
1170
int
1171
xmlUCSIsByzantineMusicalSymbols(int code) {
1172
    return(((code >= 0x1D000) && (code <= 0x1D0FF)));
1173
}
1174

1175
/**
1176
 * xmlUCSIsCJKCompatibility:
1177
 * @code: UCS code point
1178
 *
1179
 * Check whether the character is part of CJKCompatibility UCS Block
1180
 *
1181
 * Returns 1 if true 0 otherwise
1182
 */
1183
int
1184
xmlUCSIsCJKCompatibility(int code) {
1185
    return(((code >= 0x3300) && (code <= 0x33FF)));
1186
}
1187

1188
/**
1189
 * xmlUCSIsCJKCompatibilityForms:
1190
 * @code: UCS code point
1191
 *
1192
 * Check whether the character is part of CJKCompatibilityForms UCS Block
1193
 *
1194
 * Returns 1 if true 0 otherwise
1195
 */
1196
int
1197
xmlUCSIsCJKCompatibilityForms(int code) {
1198
    return(((code >= 0xFE30) && (code <= 0xFE4F)));
1199
}
1200

1201
/**
1202
 * xmlUCSIsCJKCompatibilityIdeographs:
1203
 * @code: UCS code point
1204
 *
1205
 * Check whether the character is part of CJKCompatibilityIdeographs UCS Block
1206
 *
1207
 * Returns 1 if true 0 otherwise
1208
 */
1209
int
1210
xmlUCSIsCJKCompatibilityIdeographs(int code) {
1211
    return(((code >= 0xF900) && (code <= 0xFAFF)));
1212
}
1213

1214
/**
1215
 * xmlUCSIsCJKCompatibilityIdeographsSupplement:
1216
 * @code: UCS code point
1217
 *
1218
 * Check whether the character is part of CJKCompatibilityIdeographsSupplement UCS Block
1219
 *
1220
 * Returns 1 if true 0 otherwise
1221
 */
1222
int
1223
xmlUCSIsCJKCompatibilityIdeographsSupplement(int code) {
1224
    return(((code >= 0x2F800) && (code <= 0x2FA1F)));
1225
}
1226

1227
/**
1228
 * xmlUCSIsCJKRadicalsSupplement:
1229
 * @code: UCS code point
1230
 *
1231
 * Check whether the character is part of CJKRadicalsSupplement UCS Block
1232
 *
1233
 * Returns 1 if true 0 otherwise
1234
 */
1235
int
1236
xmlUCSIsCJKRadicalsSupplement(int code) {
1237
    return(((code >= 0x2E80) && (code <= 0x2EFF)));
1238
}
1239

1240
/**
1241
 * xmlUCSIsCJKSymbolsandPunctuation:
1242
 * @code: UCS code point
1243
 *
1244
 * Check whether the character is part of CJKSymbolsandPunctuation UCS Block
1245
 *
1246
 * Returns 1 if true 0 otherwise
1247
 */
1248
int
1249
xmlUCSIsCJKSymbolsandPunctuation(int code) {
1250
    return(((code >= 0x3000) && (code <= 0x303F)));
1251
}
1252

1253
/**
1254
 * xmlUCSIsCJKUnifiedIdeographs:
1255
 * @code: UCS code point
1256
 *
1257
 * Check whether the character is part of CJKUnifiedIdeographs UCS Block
1258
 *
1259
 * Returns 1 if true 0 otherwise
1260
 */
1261
int
1262
xmlUCSIsCJKUnifiedIdeographs(int code) {
1263
    return(((code >= 0x4E00) && (code <= 0x9FFF)));
1264
}
1265

1266
/**
1267
 * xmlUCSIsCJKUnifiedIdeographsExtensionA:
1268
 * @code: UCS code point
1269
 *
1270
 * Check whether the character is part of CJKUnifiedIdeographsExtensionA UCS Block
1271
 *
1272
 * Returns 1 if true 0 otherwise
1273
 */
1274
int
1275
xmlUCSIsCJKUnifiedIdeographsExtensionA(int code) {
1276
    return(((code >= 0x3400) && (code <= 0x4DBF)));
1277
}
1278

1279
/**
1280
 * xmlUCSIsCJKUnifiedIdeographsExtensionB:
1281
 * @code: UCS code point
1282
 *
1283
 * Check whether the character is part of CJKUnifiedIdeographsExtensionB UCS Block
1284
 *
1285
 * Returns 1 if true 0 otherwise
1286
 */
1287
int
1288
xmlUCSIsCJKUnifiedIdeographsExtensionB(int code) {
1289
    return(((code >= 0x20000) && (code <= 0x2A6DF)));
1290
}
1291

1292
/**
1293
 * xmlUCSIsCherokee:
1294
 * @code: UCS code point
1295
 *
1296
 * Check whether the character is part of Cherokee UCS Block
1297
 *
1298
 * Returns 1 if true 0 otherwise
1299
 */
1300
int
1301
xmlUCSIsCherokee(int code) {
1302
    return(((code >= 0x13A0) && (code <= 0x13FF)));
1303
}
1304

1305
/**
1306
 * xmlUCSIsCombiningDiacriticalMarks:
1307
 * @code: UCS code point
1308
 *
1309
 * Check whether the character is part of CombiningDiacriticalMarks UCS Block
1310
 *
1311
 * Returns 1 if true 0 otherwise
1312
 */
1313
int
1314
xmlUCSIsCombiningDiacriticalMarks(int code) {
1315
    return(((code >= 0x0300) && (code <= 0x036F)));
1316
}
1317

1318
/**
1319
 * xmlUCSIsCombiningDiacriticalMarksforSymbols:
1320
 * @code: UCS code point
1321
 *
1322
 * Check whether the character is part of CombiningDiacriticalMarksforSymbols UCS Block
1323
 *
1324
 * Returns 1 if true 0 otherwise
1325
 */
1326
int
1327
xmlUCSIsCombiningDiacriticalMarksforSymbols(int code) {
1328
    return(((code >= 0x20D0) && (code <= 0x20FF)));
1329
}
1330

1331
/**
1332
 * xmlUCSIsCombiningHalfMarks:
1333
 * @code: UCS code point
1334
 *
1335
 * Check whether the character is part of CombiningHalfMarks UCS Block
1336
 *
1337
 * Returns 1 if true 0 otherwise
1338
 */
1339
int
1340
xmlUCSIsCombiningHalfMarks(int code) {
1341
    return(((code >= 0xFE20) && (code <= 0xFE2F)));
1342
}
1343

1344
/**
1345
 * xmlUCSIsCombiningMarksforSymbols:
1346
 * @code: UCS code point
1347
 *
1348
 * Check whether the character is part of CombiningMarksforSymbols UCS Block
1349
 *
1350
 * Returns 1 if true 0 otherwise
1351
 */
1352
int
1353
xmlUCSIsCombiningMarksforSymbols(int code) {
1354
    return(((code >= 0x20D0) && (code <= 0x20FF)));
1355
}
1356

1357
/**
1358
 * xmlUCSIsControlPictures:
1359
 * @code: UCS code point
1360
 *
1361
 * Check whether the character is part of ControlPictures UCS Block
1362
 *
1363
 * Returns 1 if true 0 otherwise
1364
 */
1365
int
1366
xmlUCSIsControlPictures(int code) {
1367
    return(((code >= 0x2400) && (code <= 0x243F)));
1368
}
1369

1370
/**
1371
 * xmlUCSIsCurrencySymbols:
1372
 * @code: UCS code point
1373
 *
1374
 * Check whether the character is part of CurrencySymbols UCS Block
1375
 *
1376
 * Returns 1 if true 0 otherwise
1377
 */
1378
int
1379
xmlUCSIsCurrencySymbols(int code) {
1380
    return(((code >= 0x20A0) && (code <= 0x20CF)));
1381
}
1382

1383
/**
1384
 * xmlUCSIsCypriotSyllabary:
1385
 * @code: UCS code point
1386
 *
1387
 * Check whether the character is part of CypriotSyllabary UCS Block
1388
 *
1389
 * Returns 1 if true 0 otherwise
1390
 */
1391
int
1392
xmlUCSIsCypriotSyllabary(int code) {
1393
    return(((code >= 0x10800) && (code <= 0x1083F)));
1394
}
1395

1396
/**
1397
 * xmlUCSIsCyrillic:
1398
 * @code: UCS code point
1399
 *
1400
 * Check whether the character is part of Cyrillic UCS Block
1401
 *
1402
 * Returns 1 if true 0 otherwise
1403
 */
1404
int
1405
xmlUCSIsCyrillic(int code) {
1406
    return(((code >= 0x0400) && (code <= 0x04FF)));
1407
}
1408

1409
/**
1410
 * xmlUCSIsCyrillicSupplement:
1411
 * @code: UCS code point
1412
 *
1413
 * Check whether the character is part of CyrillicSupplement UCS Block
1414
 *
1415
 * Returns 1 if true 0 otherwise
1416
 */
1417
int
1418
xmlUCSIsCyrillicSupplement(int code) {
1419
    return(((code >= 0x0500) && (code <= 0x052F)));
1420
}
1421

1422
/**
1423
 * xmlUCSIsDeseret:
1424
 * @code: UCS code point
1425
 *
1426
 * Check whether the character is part of Deseret UCS Block
1427
 *
1428
 * Returns 1 if true 0 otherwise
1429
 */
1430
int
1431
xmlUCSIsDeseret(int code) {
1432
    return(((code >= 0x10400) && (code <= 0x1044F)));
1433
}
1434

1435
/**
1436
 * xmlUCSIsDevanagari:
1437
 * @code: UCS code point
1438
 *
1439
 * Check whether the character is part of Devanagari UCS Block
1440
 *
1441
 * Returns 1 if true 0 otherwise
1442
 */
1443
int
1444
xmlUCSIsDevanagari(int code) {
1445
    return(((code >= 0x0900) && (code <= 0x097F)));
1446
}
1447

1448
/**
1449
 * xmlUCSIsDingbats:
1450
 * @code: UCS code point
1451
 *
1452
 * Check whether the character is part of Dingbats UCS Block
1453
 *
1454
 * Returns 1 if true 0 otherwise
1455
 */
1456
int
1457
xmlUCSIsDingbats(int code) {
1458
    return(((code >= 0x2700) && (code <= 0x27BF)));
1459
}
1460

1461
/**
1462
 * xmlUCSIsEnclosedAlphanumerics:
1463
 * @code: UCS code point
1464
 *
1465
 * Check whether the character is part of EnclosedAlphanumerics UCS Block
1466
 *
1467
 * Returns 1 if true 0 otherwise
1468
 */
1469
int
1470
xmlUCSIsEnclosedAlphanumerics(int code) {
1471
    return(((code >= 0x2460) && (code <= 0x24FF)));
1472
}
1473

1474
/**
1475
 * xmlUCSIsEnclosedCJKLettersandMonths:
1476
 * @code: UCS code point
1477
 *
1478
 * Check whether the character is part of EnclosedCJKLettersandMonths UCS Block
1479
 *
1480
 * Returns 1 if true 0 otherwise
1481
 */
1482
int
1483
xmlUCSIsEnclosedCJKLettersandMonths(int code) {
1484
    return(((code >= 0x3200) && (code <= 0x32FF)));
1485
}
1486

1487
/**
1488
 * xmlUCSIsEthiopic:
1489
 * @code: UCS code point
1490
 *
1491
 * Check whether the character is part of Ethiopic UCS Block
1492
 *
1493
 * Returns 1 if true 0 otherwise
1494
 */
1495
int
1496
xmlUCSIsEthiopic(int code) {
1497
    return(((code >= 0x1200) && (code <= 0x137F)));
1498
}
1499

1500
/**
1501
 * xmlUCSIsGeneralPunctuation:
1502
 * @code: UCS code point
1503
 *
1504
 * Check whether the character is part of GeneralPunctuation UCS Block
1505
 *
1506
 * Returns 1 if true 0 otherwise
1507
 */
1508
int
1509
xmlUCSIsGeneralPunctuation(int code) {
1510
    return(((code >= 0x2000) && (code <= 0x206F)));
1511
}
1512

1513
/**
1514
 * xmlUCSIsGeometricShapes:
1515
 * @code: UCS code point
1516
 *
1517
 * Check whether the character is part of GeometricShapes UCS Block
1518
 *
1519
 * Returns 1 if true 0 otherwise
1520
 */
1521
int
1522
xmlUCSIsGeometricShapes(int code) {
1523
    return(((code >= 0x25A0) && (code <= 0x25FF)));
1524
}
1525

1526
/**
1527
 * xmlUCSIsGeorgian:
1528
 * @code: UCS code point
1529
 *
1530
 * Check whether the character is part of Georgian UCS Block
1531
 *
1532
 * Returns 1 if true 0 otherwise
1533
 */
1534
int
1535
xmlUCSIsGeorgian(int code) {
1536
    return(((code >= 0x10A0) && (code <= 0x10FF)));
1537
}
1538

1539
/**
1540
 * xmlUCSIsGothic:
1541
 * @code: UCS code point
1542
 *
1543
 * Check whether the character is part of Gothic UCS Block
1544
 *
1545
 * Returns 1 if true 0 otherwise
1546
 */
1547
int
1548
xmlUCSIsGothic(int code) {
1549
    return(((code >= 0x10330) && (code <= 0x1034F)));
1550
}
1551

1552
/**
1553
 * xmlUCSIsGreek:
1554
 * @code: UCS code point
1555
 *
1556
 * Check whether the character is part of Greek UCS Block
1557
 *
1558
 * Returns 1 if true 0 otherwise
1559
 */
1560
int
1561
xmlUCSIsGreek(int code) {
1562
    return(((code >= 0x0370) && (code <= 0x03FF)));
1563
}
1564

1565
/**
1566
 * xmlUCSIsGreekExtended:
1567
 * @code: UCS code point
1568
 *
1569
 * Check whether the character is part of GreekExtended UCS Block
1570
 *
1571
 * Returns 1 if true 0 otherwise
1572
 */
1573
int
1574
xmlUCSIsGreekExtended(int code) {
1575
    return(((code >= 0x1F00) && (code <= 0x1FFF)));
1576
}
1577

1578
/**
1579
 * xmlUCSIsGreekandCoptic:
1580
 * @code: UCS code point
1581
 *
1582
 * Check whether the character is part of GreekandCoptic UCS Block
1583
 *
1584
 * Returns 1 if true 0 otherwise
1585
 */
1586
int
1587
xmlUCSIsGreekandCoptic(int code) {
1588
    return(((code >= 0x0370) && (code <= 0x03FF)));
1589
}
1590

1591
/**
1592
 * xmlUCSIsGujarati:
1593
 * @code: UCS code point
1594
 *
1595
 * Check whether the character is part of Gujarati UCS Block
1596
 *
1597
 * Returns 1 if true 0 otherwise
1598
 */
1599
int
1600
xmlUCSIsGujarati(int code) {
1601
    return(((code >= 0x0A80) && (code <= 0x0AFF)));
1602
}
1603

1604
/**
1605
 * xmlUCSIsGurmukhi:
1606
 * @code: UCS code point
1607
 *
1608
 * Check whether the character is part of Gurmukhi UCS Block
1609
 *
1610
 * Returns 1 if true 0 otherwise
1611
 */
1612
int
1613
xmlUCSIsGurmukhi(int code) {
1614
    return(((code >= 0x0A00) && (code <= 0x0A7F)));
1615
}
1616

1617
/**
1618
 * xmlUCSIsHalfwidthandFullwidthForms:
1619
 * @code: UCS code point
1620
 *
1621
 * Check whether the character is part of HalfwidthandFullwidthForms UCS Block
1622
 *
1623
 * Returns 1 if true 0 otherwise
1624
 */
1625
int
1626
xmlUCSIsHalfwidthandFullwidthForms(int code) {
1627
    return(((code >= 0xFF00) && (code <= 0xFFEF)));
1628
}
1629

1630
/**
1631
 * xmlUCSIsHangulCompatibilityJamo:
1632
 * @code: UCS code point
1633
 *
1634
 * Check whether the character is part of HangulCompatibilityJamo UCS Block
1635
 *
1636
 * Returns 1 if true 0 otherwise
1637
 */
1638
int
1639
xmlUCSIsHangulCompatibilityJamo(int code) {
1640
    return(((code >= 0x3130) && (code <= 0x318F)));
1641
}
1642

1643
/**
1644
 * xmlUCSIsHangulJamo:
1645
 * @code: UCS code point
1646
 *
1647
 * Check whether the character is part of HangulJamo UCS Block
1648
 *
1649
 * Returns 1 if true 0 otherwise
1650
 */
1651
int
1652
xmlUCSIsHangulJamo(int code) {
1653
    return(((code >= 0x1100) && (code <= 0x11FF)));
1654
}
1655

1656
/**
1657
 * xmlUCSIsHangulSyllables:
1658
 * @code: UCS code point
1659
 *
1660
 * Check whether the character is part of HangulSyllables UCS Block
1661
 *
1662
 * Returns 1 if true 0 otherwise
1663
 */
1664
int
1665
xmlUCSIsHangulSyllables(int code) {
1666
    return(((code >= 0xAC00) && (code <= 0xD7AF)));
1667
}
1668

1669
/**
1670
 * xmlUCSIsHanunoo:
1671
 * @code: UCS code point
1672
 *
1673
 * Check whether the character is part of Hanunoo UCS Block
1674
 *
1675
 * Returns 1 if true 0 otherwise
1676
 */
1677
int
1678
xmlUCSIsHanunoo(int code) {
1679
    return(((code >= 0x1720) && (code <= 0x173F)));
1680
}
1681

1682
/**
1683
 * xmlUCSIsHebrew:
1684
 * @code: UCS code point
1685
 *
1686
 * Check whether the character is part of Hebrew UCS Block
1687
 *
1688
 * Returns 1 if true 0 otherwise
1689
 */
1690
int
1691
xmlUCSIsHebrew(int code) {
1692
    return(((code >= 0x0590) && (code <= 0x05FF)));
1693
}
1694

1695
/**
1696
 * xmlUCSIsHighPrivateUseSurrogates:
1697
 * @code: UCS code point
1698
 *
1699
 * Check whether the character is part of HighPrivateUseSurrogates UCS Block
1700
 *
1701
 * Returns 1 if true 0 otherwise
1702
 */
1703
int
1704
xmlUCSIsHighPrivateUseSurrogates(int code) {
1705
    return(((code >= 0xDB80) && (code <= 0xDBFF)));
1706
}
1707

1708
/**
1709
 * xmlUCSIsHighSurrogates:
1710
 * @code: UCS code point
1711
 *
1712
 * Check whether the character is part of HighSurrogates UCS Block
1713
 *
1714
 * Returns 1 if true 0 otherwise
1715
 */
1716
int
1717
xmlUCSIsHighSurrogates(int code) {
1718
    return(((code >= 0xD800) && (code <= 0xDB7F)));
1719
}
1720

1721
/**
1722
 * xmlUCSIsHiragana:
1723
 * @code: UCS code point
1724
 *
1725
 * Check whether the character is part of Hiragana UCS Block
1726
 *
1727
 * Returns 1 if true 0 otherwise
1728
 */
1729
int
1730
xmlUCSIsHiragana(int code) {
1731
    return(((code >= 0x3040) && (code <= 0x309F)));
1732
}
1733

1734
/**
1735
 * xmlUCSIsIPAExtensions:
1736
 * @code: UCS code point
1737
 *
1738
 * Check whether the character is part of IPAExtensions UCS Block
1739
 *
1740
 * Returns 1 if true 0 otherwise
1741
 */
1742
int
1743
xmlUCSIsIPAExtensions(int code) {
1744
    return(((code >= 0x0250) && (code <= 0x02AF)));
1745
}
1746

1747
/**
1748
 * xmlUCSIsIdeographicDescriptionCharacters:
1749
 * @code: UCS code point
1750
 *
1751
 * Check whether the character is part of IdeographicDescriptionCharacters UCS Block
1752
 *
1753
 * Returns 1 if true 0 otherwise
1754
 */
1755
int
1756
xmlUCSIsIdeographicDescriptionCharacters(int code) {
1757
    return(((code >= 0x2FF0) && (code <= 0x2FFF)));
1758
}
1759

1760
/**
1761
 * xmlUCSIsKanbun:
1762
 * @code: UCS code point
1763
 *
1764
 * Check whether the character is part of Kanbun UCS Block
1765
 *
1766
 * Returns 1 if true 0 otherwise
1767
 */
1768
int
1769
xmlUCSIsKanbun(int code) {
1770
    return(((code >= 0x3190) && (code <= 0x319F)));
1771
}
1772

1773
/**
1774
 * xmlUCSIsKangxiRadicals:
1775
 * @code: UCS code point
1776
 *
1777
 * Check whether the character is part of KangxiRadicals UCS Block
1778
 *
1779
 * Returns 1 if true 0 otherwise
1780
 */
1781
int
1782
xmlUCSIsKangxiRadicals(int code) {
1783
    return(((code >= 0x2F00) && (code <= 0x2FDF)));
1784
}
1785

1786
/**
1787
 * xmlUCSIsKannada:
1788
 * @code: UCS code point
1789
 *
1790
 * Check whether the character is part of Kannada UCS Block
1791
 *
1792
 * Returns 1 if true 0 otherwise
1793
 */
1794
int
1795
xmlUCSIsKannada(int code) {
1796
    return(((code >= 0x0C80) && (code <= 0x0CFF)));
1797
}
1798

1799
/**
1800
 * xmlUCSIsKatakana:
1801
 * @code: UCS code point
1802
 *
1803
 * Check whether the character is part of Katakana UCS Block
1804
 *
1805
 * Returns 1 if true 0 otherwise
1806
 */
1807
int
1808
xmlUCSIsKatakana(int code) {
1809
    return(((code >= 0x30A0) && (code <= 0x30FF)));
1810
}
1811

1812
/**
1813
 * xmlUCSIsKatakanaPhoneticExtensions:
1814
 * @code: UCS code point
1815
 *
1816
 * Check whether the character is part of KatakanaPhoneticExtensions UCS Block
1817
 *
1818
 * Returns 1 if true 0 otherwise
1819
 */
1820
int
1821
xmlUCSIsKatakanaPhoneticExtensions(int code) {
1822
    return(((code >= 0x31F0) && (code <= 0x31FF)));
1823
}
1824

1825
/**
1826
 * xmlUCSIsKhmer:
1827
 * @code: UCS code point
1828
 *
1829
 * Check whether the character is part of Khmer UCS Block
1830
 *
1831
 * Returns 1 if true 0 otherwise
1832
 */
1833
int
1834
xmlUCSIsKhmer(int code) {
1835
    return(((code >= 0x1780) && (code <= 0x17FF)));
1836
}
1837

1838
/**
1839
 * xmlUCSIsKhmerSymbols:
1840
 * @code: UCS code point
1841
 *
1842
 * Check whether the character is part of KhmerSymbols UCS Block
1843
 *
1844
 * Returns 1 if true 0 otherwise
1845
 */
1846
int
1847
xmlUCSIsKhmerSymbols(int code) {
1848
    return(((code >= 0x19E0) && (code <= 0x19FF)));
1849
}
1850

1851
/**
1852
 * xmlUCSIsLao:
1853
 * @code: UCS code point
1854
 *
1855
 * Check whether the character is part of Lao UCS Block
1856
 *
1857
 * Returns 1 if true 0 otherwise
1858
 */
1859
int
1860
xmlUCSIsLao(int code) {
1861
    return(((code >= 0x0E80) && (code <= 0x0EFF)));
1862
}
1863

1864
/**
1865
 * xmlUCSIsLatin1Supplement:
1866
 * @code: UCS code point
1867
 *
1868
 * Check whether the character is part of Latin-1Supplement UCS Block
1869
 *
1870
 * Returns 1 if true 0 otherwise
1871
 */
1872
int
1873
xmlUCSIsLatin1Supplement(int code) {
1874
    return(((code >= 0x0080) && (code <= 0x00FF)));
1875
}
1876

1877
/**
1878
 * xmlUCSIsLatinExtendedA:
1879
 * @code: UCS code point
1880
 *
1881
 * Check whether the character is part of LatinExtended-A UCS Block
1882
 *
1883
 * Returns 1 if true 0 otherwise
1884
 */
1885
int
1886
xmlUCSIsLatinExtendedA(int code) {
1887
    return(((code >= 0x0100) && (code <= 0x017F)));
1888
}
1889

1890
/**
1891
 * xmlUCSIsLatinExtendedB:
1892
 * @code: UCS code point
1893
 *
1894
 * Check whether the character is part of LatinExtended-B UCS Block
1895
 *
1896
 * Returns 1 if true 0 otherwise
1897
 */
1898
int
1899
xmlUCSIsLatinExtendedB(int code) {
1900
    return(((code >= 0x0180) && (code <= 0x024F)));
1901
}
1902

1903
/**
1904
 * xmlUCSIsLatinExtendedAdditional:
1905
 * @code: UCS code point
1906
 *
1907
 * Check whether the character is part of LatinExtendedAdditional UCS Block
1908
 *
1909
 * Returns 1 if true 0 otherwise
1910
 */
1911
int
1912
xmlUCSIsLatinExtendedAdditional(int code) {
1913
    return(((code >= 0x1E00) && (code <= 0x1EFF)));
1914
}
1915

1916
/**
1917
 * xmlUCSIsLetterlikeSymbols:
1918
 * @code: UCS code point
1919
 *
1920
 * Check whether the character is part of LetterlikeSymbols UCS Block
1921
 *
1922
 * Returns 1 if true 0 otherwise
1923
 */
1924
int
1925
xmlUCSIsLetterlikeSymbols(int code) {
1926
    return(((code >= 0x2100) && (code <= 0x214F)));
1927
}
1928

1929
/**
1930
 * xmlUCSIsLimbu:
1931
 * @code: UCS code point
1932
 *
1933
 * Check whether the character is part of Limbu UCS Block
1934
 *
1935
 * Returns 1 if true 0 otherwise
1936
 */
1937
int
1938
xmlUCSIsLimbu(int code) {
1939
    return(((code >= 0x1900) && (code <= 0x194F)));
1940
}
1941

1942
/**
1943
 * xmlUCSIsLinearBIdeograms:
1944
 * @code: UCS code point
1945
 *
1946
 * Check whether the character is part of LinearBIdeograms UCS Block
1947
 *
1948
 * Returns 1 if true 0 otherwise
1949
 */
1950
int
1951
xmlUCSIsLinearBIdeograms(int code) {
1952
    return(((code >= 0x10080) && (code <= 0x100FF)));
1953
}
1954

1955
/**
1956
 * xmlUCSIsLinearBSyllabary:
1957
 * @code: UCS code point
1958
 *
1959
 * Check whether the character is part of LinearBSyllabary UCS Block
1960
 *
1961
 * Returns 1 if true 0 otherwise
1962
 */
1963
int
1964
xmlUCSIsLinearBSyllabary(int code) {
1965
    return(((code >= 0x10000) && (code <= 0x1007F)));
1966
}
1967

1968
/**
1969
 * xmlUCSIsLowSurrogates:
1970
 * @code: UCS code point
1971
 *
1972
 * Check whether the character is part of LowSurrogates UCS Block
1973
 *
1974
 * Returns 1 if true 0 otherwise
1975
 */
1976
int
1977
xmlUCSIsLowSurrogates(int code) {
1978
    return(((code >= 0xDC00) && (code <= 0xDFFF)));
1979
}
1980

1981
/**
1982
 * xmlUCSIsMalayalam:
1983
 * @code: UCS code point
1984
 *
1985
 * Check whether the character is part of Malayalam UCS Block
1986
 *
1987
 * Returns 1 if true 0 otherwise
1988
 */
1989
int
1990
xmlUCSIsMalayalam(int code) {
1991
    return(((code >= 0x0D00) && (code <= 0x0D7F)));
1992
}
1993

1994
/**
1995
 * xmlUCSIsMathematicalAlphanumericSymbols:
1996
 * @code: UCS code point
1997
 *
1998
 * Check whether the character is part of MathematicalAlphanumericSymbols UCS Block
1999
 *
2000
 * Returns 1 if true 0 otherwise
2001
 */
2002
int
2003
xmlUCSIsMathematicalAlphanumericSymbols(int code) {
2004
    return(((code >= 0x1D400) && (code <= 0x1D7FF)));
2005
}
2006

2007
/**
2008
 * xmlUCSIsMathematicalOperators:
2009
 * @code: UCS code point
2010
 *
2011
 * Check whether the character is part of MathematicalOperators UCS Block
2012
 *
2013
 * Returns 1 if true 0 otherwise
2014
 */
2015
int
2016
xmlUCSIsMathematicalOperators(int code) {
2017
    return(((code >= 0x2200) && (code <= 0x22FF)));
2018
}
2019

2020
/**
2021
 * xmlUCSIsMiscellaneousMathematicalSymbolsA:
2022
 * @code: UCS code point
2023
 *
2024
 * Check whether the character is part of MiscellaneousMathematicalSymbols-A UCS Block
2025
 *
2026
 * Returns 1 if true 0 otherwise
2027
 */
2028
int
2029
xmlUCSIsMiscellaneousMathematicalSymbolsA(int code) {
2030
    return(((code >= 0x27C0) && (code <= 0x27EF)));
2031
}
2032

2033
/**
2034
 * xmlUCSIsMiscellaneousMathematicalSymbolsB:
2035
 * @code: UCS code point
2036
 *
2037
 * Check whether the character is part of MiscellaneousMathematicalSymbols-B UCS Block
2038
 *
2039
 * Returns 1 if true 0 otherwise
2040
 */
2041
int
2042
xmlUCSIsMiscellaneousMathematicalSymbolsB(int code) {
2043
    return(((code >= 0x2980) && (code <= 0x29FF)));
2044
}
2045

2046
/**
2047
 * xmlUCSIsMiscellaneousSymbols:
2048
 * @code: UCS code point
2049
 *
2050
 * Check whether the character is part of MiscellaneousSymbols UCS Block
2051
 *
2052
 * Returns 1 if true 0 otherwise
2053
 */
2054
int
2055
xmlUCSIsMiscellaneousSymbols(int code) {
2056
    return(((code >= 0x2600) && (code <= 0x26FF)));
2057
}
2058

2059
/**
2060
 * xmlUCSIsMiscellaneousSymbolsandArrows:
2061
 * @code: UCS code point
2062
 *
2063
 * Check whether the character is part of MiscellaneousSymbolsandArrows UCS Block
2064
 *
2065
 * Returns 1 if true 0 otherwise
2066
 */
2067
int
2068
xmlUCSIsMiscellaneousSymbolsandArrows(int code) {
2069
    return(((code >= 0x2B00) && (code <= 0x2BFF)));
2070
}
2071

2072
/**
2073
 * xmlUCSIsMiscellaneousTechnical:
2074
 * @code: UCS code point
2075
 *
2076
 * Check whether the character is part of MiscellaneousTechnical UCS Block
2077
 *
2078
 * Returns 1 if true 0 otherwise
2079
 */
2080
int
2081
xmlUCSIsMiscellaneousTechnical(int code) {
2082
    return(((code >= 0x2300) && (code <= 0x23FF)));
2083
}
2084

2085
/**
2086
 * xmlUCSIsMongolian:
2087
 * @code: UCS code point
2088
 *
2089
 * Check whether the character is part of Mongolian UCS Block
2090
 *
2091
 * Returns 1 if true 0 otherwise
2092
 */
2093
int
2094
xmlUCSIsMongolian(int code) {
2095
    return(((code >= 0x1800) && (code <= 0x18AF)));
2096
}
2097

2098
/**
2099
 * xmlUCSIsMusicalSymbols:
2100
 * @code: UCS code point
2101
 *
2102
 * Check whether the character is part of MusicalSymbols UCS Block
2103
 *
2104
 * Returns 1 if true 0 otherwise
2105
 */
2106
int
2107
xmlUCSIsMusicalSymbols(int code) {
2108
    return(((code >= 0x1D100) && (code <= 0x1D1FF)));
2109
}
2110

2111
/**
2112
 * xmlUCSIsMyanmar:
2113
 * @code: UCS code point
2114
 *
2115
 * Check whether the character is part of Myanmar UCS Block
2116
 *
2117
 * Returns 1 if true 0 otherwise
2118
 */
2119
int
2120
xmlUCSIsMyanmar(int code) {
2121
    return(((code >= 0x1000) && (code <= 0x109F)));
2122
}
2123

2124
/**
2125
 * xmlUCSIsNumberForms:
2126
 * @code: UCS code point
2127
 *
2128
 * Check whether the character is part of NumberForms UCS Block
2129
 *
2130
 * Returns 1 if true 0 otherwise
2131
 */
2132
int
2133
xmlUCSIsNumberForms(int code) {
2134
    return(((code >= 0x2150) && (code <= 0x218F)));
2135
}
2136

2137
/**
2138
 * xmlUCSIsOgham:
2139
 * @code: UCS code point
2140
 *
2141
 * Check whether the character is part of Ogham UCS Block
2142
 *
2143
 * Returns 1 if true 0 otherwise
2144
 */
2145
int
2146
xmlUCSIsOgham(int code) {
2147
    return(((code >= 0x1680) && (code <= 0x169F)));
2148
}
2149

2150
/**
2151
 * xmlUCSIsOldItalic:
2152
 * @code: UCS code point
2153
 *
2154
 * Check whether the character is part of OldItalic UCS Block
2155
 *
2156
 * Returns 1 if true 0 otherwise
2157
 */
2158
int
2159
xmlUCSIsOldItalic(int code) {
2160
    return(((code >= 0x10300) && (code <= 0x1032F)));
2161
}
2162

2163
/**
2164
 * xmlUCSIsOpticalCharacterRecognition:
2165
 * @code: UCS code point
2166
 *
2167
 * Check whether the character is part of OpticalCharacterRecognition UCS Block
2168
 *
2169
 * Returns 1 if true 0 otherwise
2170
 */
2171
int
2172
xmlUCSIsOpticalCharacterRecognition(int code) {
2173
    return(((code >= 0x2440) && (code <= 0x245F)));
2174
}
2175

2176
/**
2177
 * xmlUCSIsOriya:
2178
 * @code: UCS code point
2179
 *
2180
 * Check whether the character is part of Oriya UCS Block
2181
 *
2182
 * Returns 1 if true 0 otherwise
2183
 */
2184
int
2185
xmlUCSIsOriya(int code) {
2186
    return(((code >= 0x0B00) && (code <= 0x0B7F)));
2187
}
2188

2189
/**
2190
 * xmlUCSIsOsmanya:
2191
 * @code: UCS code point
2192
 *
2193
 * Check whether the character is part of Osmanya UCS Block
2194
 *
2195
 * Returns 1 if true 0 otherwise
2196
 */
2197
int
2198
xmlUCSIsOsmanya(int code) {
2199
    return(((code >= 0x10480) && (code <= 0x104AF)));
2200
}
2201

2202
/**
2203
 * xmlUCSIsPhoneticExtensions:
2204
 * @code: UCS code point
2205
 *
2206
 * Check whether the character is part of PhoneticExtensions UCS Block
2207
 *
2208
 * Returns 1 if true 0 otherwise
2209
 */
2210
int
2211
xmlUCSIsPhoneticExtensions(int code) {
2212
    return(((code >= 0x1D00) && (code <= 0x1D7F)));
2213
}
2214

2215
/**
2216
 * xmlUCSIsPrivateUse:
2217
 * @code: UCS code point
2218
 *
2219
 * Check whether the character is part of PrivateUse UCS Block
2220
 *
2221
 * Returns 1 if true 0 otherwise
2222
 */
2223
int
2224
xmlUCSIsPrivateUse(int code) {
2225
    return(((code >= 0xE000) && (code <= 0xF8FF)) ||
2226
           ((code >= 0xF0000) && (code <= 0xFFFFF)) ||
2227
           ((code >= 0x100000) && (code <= 0x10FFFF)));
2228
}
2229

2230
/**
2231
 * xmlUCSIsPrivateUseArea:
2232
 * @code: UCS code point
2233
 *
2234
 * Check whether the character is part of PrivateUseArea UCS Block
2235
 *
2236
 * Returns 1 if true 0 otherwise
2237
 */
2238
int
2239
xmlUCSIsPrivateUseArea(int code) {
2240
    return(((code >= 0xE000) && (code <= 0xF8FF)));
2241
}
2242

2243
/**
2244
 * xmlUCSIsRunic:
2245
 * @code: UCS code point
2246
 *
2247
 * Check whether the character is part of Runic UCS Block
2248
 *
2249
 * Returns 1 if true 0 otherwise
2250
 */
2251
int
2252
xmlUCSIsRunic(int code) {
2253
    return(((code >= 0x16A0) && (code <= 0x16FF)));
2254
}
2255

2256
/**
2257
 * xmlUCSIsShavian:
2258
 * @code: UCS code point
2259
 *
2260
 * Check whether the character is part of Shavian UCS Block
2261
 *
2262
 * Returns 1 if true 0 otherwise
2263
 */
2264
int
2265
xmlUCSIsShavian(int code) {
2266
    return(((code >= 0x10450) && (code <= 0x1047F)));
2267
}
2268

2269
/**
2270
 * xmlUCSIsSinhala:
2271
 * @code: UCS code point
2272
 *
2273
 * Check whether the character is part of Sinhala UCS Block
2274
 *
2275
 * Returns 1 if true 0 otherwise
2276
 */
2277
int
2278
xmlUCSIsSinhala(int code) {
2279
    return(((code >= 0x0D80) && (code <= 0x0DFF)));
2280
}
2281

2282
/**
2283
 * xmlUCSIsSmallFormVariants:
2284
 * @code: UCS code point
2285
 *
2286
 * Check whether the character is part of SmallFormVariants UCS Block
2287
 *
2288
 * Returns 1 if true 0 otherwise
2289
 */
2290
int
2291
xmlUCSIsSmallFormVariants(int code) {
2292
    return(((code >= 0xFE50) && (code <= 0xFE6F)));
2293
}
2294

2295
/**
2296
 * xmlUCSIsSpacingModifierLetters:
2297
 * @code: UCS code point
2298
 *
2299
 * Check whether the character is part of SpacingModifierLetters UCS Block
2300
 *
2301
 * Returns 1 if true 0 otherwise
2302
 */
2303
int
2304
xmlUCSIsSpacingModifierLetters(int code) {
2305
    return(((code >= 0x02B0) && (code <= 0x02FF)));
2306
}
2307

2308
/**
2309
 * xmlUCSIsSpecials:
2310
 * @code: UCS code point
2311
 *
2312
 * Check whether the character is part of Specials UCS Block
2313
 *
2314
 * Returns 1 if true 0 otherwise
2315
 */
2316
int
2317
xmlUCSIsSpecials(int code) {
2318
    return(((code >= 0xFFF0) && (code <= 0xFFFF)));
2319
}
2320

2321
/**
2322
 * xmlUCSIsSuperscriptsandSubscripts:
2323
 * @code: UCS code point
2324
 *
2325
 * Check whether the character is part of SuperscriptsandSubscripts UCS Block
2326
 *
2327
 * Returns 1 if true 0 otherwise
2328
 */
2329
int
2330
xmlUCSIsSuperscriptsandSubscripts(int code) {
2331
    return(((code >= 0x2070) && (code <= 0x209F)));
2332
}
2333

2334
/**
2335
 * xmlUCSIsSupplementalArrowsA:
2336
 * @code: UCS code point
2337
 *
2338
 * Check whether the character is part of SupplementalArrows-A UCS Block
2339
 *
2340
 * Returns 1 if true 0 otherwise
2341
 */
2342
int
2343
xmlUCSIsSupplementalArrowsA(int code) {
2344
    return(((code >= 0x27F0) && (code <= 0x27FF)));
2345
}
2346

2347
/**
2348
 * xmlUCSIsSupplementalArrowsB:
2349
 * @code: UCS code point
2350
 *
2351
 * Check whether the character is part of SupplementalArrows-B UCS Block
2352
 *
2353
 * Returns 1 if true 0 otherwise
2354
 */
2355
int
2356
xmlUCSIsSupplementalArrowsB(int code) {
2357
    return(((code >= 0x2900) && (code <= 0x297F)));
2358
}
2359

2360
/**
2361
 * xmlUCSIsSupplementalMathematicalOperators:
2362
 * @code: UCS code point
2363
 *
2364
 * Check whether the character is part of SupplementalMathematicalOperators UCS Block
2365
 *
2366
 * Returns 1 if true 0 otherwise
2367
 */
2368
int
2369
xmlUCSIsSupplementalMathematicalOperators(int code) {
2370
    return(((code >= 0x2A00) && (code <= 0x2AFF)));
2371
}
2372

2373
/**
2374
 * xmlUCSIsSupplementaryPrivateUseAreaA:
2375
 * @code: UCS code point
2376
 *
2377
 * Check whether the character is part of SupplementaryPrivateUseArea-A UCS Block
2378
 *
2379
 * Returns 1 if true 0 otherwise
2380
 */
2381
int
2382
xmlUCSIsSupplementaryPrivateUseAreaA(int code) {
2383
    return(((code >= 0xF0000) && (code <= 0xFFFFF)));
2384
}
2385

2386
/**
2387
 * xmlUCSIsSupplementaryPrivateUseAreaB:
2388
 * @code: UCS code point
2389
 *
2390
 * Check whether the character is part of SupplementaryPrivateUseArea-B UCS Block
2391
 *
2392
 * Returns 1 if true 0 otherwise
2393
 */
2394
int
2395
xmlUCSIsSupplementaryPrivateUseAreaB(int code) {
2396
    return(((code >= 0x100000) && (code <= 0x10FFFF)));
2397
}
2398

2399
/**
2400
 * xmlUCSIsSyriac:
2401
 * @code: UCS code point
2402
 *
2403
 * Check whether the character is part of Syriac UCS Block
2404
 *
2405
 * Returns 1 if true 0 otherwise
2406
 */
2407
int
2408
xmlUCSIsSyriac(int code) {
2409
    return(((code >= 0x0700) && (code <= 0x074F)));
2410
}
2411

2412
/**
2413
 * xmlUCSIsTagalog:
2414
 * @code: UCS code point
2415
 *
2416
 * Check whether the character is part of Tagalog UCS Block
2417
 *
2418
 * Returns 1 if true 0 otherwise
2419
 */
2420
int
2421
xmlUCSIsTagalog(int code) {
2422
    return(((code >= 0x1700) && (code <= 0x171F)));
2423
}
2424

2425
/**
2426
 * xmlUCSIsTagbanwa:
2427
 * @code: UCS code point
2428
 *
2429
 * Check whether the character is part of Tagbanwa UCS Block
2430
 *
2431
 * Returns 1 if true 0 otherwise
2432
 */
2433
int
2434
xmlUCSIsTagbanwa(int code) {
2435
    return(((code >= 0x1760) && (code <= 0x177F)));
2436
}
2437

2438
/**
2439
 * xmlUCSIsTags:
2440
 * @code: UCS code point
2441
 *
2442
 * Check whether the character is part of Tags UCS Block
2443
 *
2444
 * Returns 1 if true 0 otherwise
2445
 */
2446
int
2447
xmlUCSIsTags(int code) {
2448
    return(((code >= 0xE0000) && (code <= 0xE007F)));
2449
}
2450

2451
/**
2452
 * xmlUCSIsTaiLe:
2453
 * @code: UCS code point
2454
 *
2455
 * Check whether the character is part of TaiLe UCS Block
2456
 *
2457
 * Returns 1 if true 0 otherwise
2458
 */
2459
int
2460
xmlUCSIsTaiLe(int code) {
2461
    return(((code >= 0x1950) && (code <= 0x197F)));
2462
}
2463

2464
/**
2465
 * xmlUCSIsTaiXuanJingSymbols:
2466
 * @code: UCS code point
2467
 *
2468
 * Check whether the character is part of TaiXuanJingSymbols UCS Block
2469
 *
2470
 * Returns 1 if true 0 otherwise
2471
 */
2472
int
2473
xmlUCSIsTaiXuanJingSymbols(int code) {
2474
    return(((code >= 0x1D300) && (code <= 0x1D35F)));
2475
}
2476

2477
/**
2478
 * xmlUCSIsTamil:
2479
 * @code: UCS code point
2480
 *
2481
 * Check whether the character is part of Tamil UCS Block
2482
 *
2483
 * Returns 1 if true 0 otherwise
2484
 */
2485
int
2486
xmlUCSIsTamil(int code) {
2487
    return(((code >= 0x0B80) && (code <= 0x0BFF)));
2488
}
2489

2490
/**
2491
 * xmlUCSIsTelugu:
2492
 * @code: UCS code point
2493
 *
2494
 * Check whether the character is part of Telugu UCS Block
2495
 *
2496
 * Returns 1 if true 0 otherwise
2497
 */
2498
int
2499
xmlUCSIsTelugu(int code) {
2500
    return(((code >= 0x0C00) && (code <= 0x0C7F)));
2501
}
2502

2503
/**
2504
 * xmlUCSIsThaana:
2505
 * @code: UCS code point
2506
 *
2507
 * Check whether the character is part of Thaana UCS Block
2508
 *
2509
 * Returns 1 if true 0 otherwise
2510
 */
2511
int
2512
xmlUCSIsThaana(int code) {
2513
    return(((code >= 0x0780) && (code <= 0x07BF)));
2514
}
2515

2516
/**
2517
 * xmlUCSIsThai:
2518
 * @code: UCS code point
2519
 *
2520
 * Check whether the character is part of Thai UCS Block
2521
 *
2522
 * Returns 1 if true 0 otherwise
2523
 */
2524
int
2525
xmlUCSIsThai(int code) {
2526
    return(((code >= 0x0E00) && (code <= 0x0E7F)));
2527
}
2528

2529
/**
2530
 * xmlUCSIsTibetan:
2531
 * @code: UCS code point
2532
 *
2533
 * Check whether the character is part of Tibetan UCS Block
2534
 *
2535
 * Returns 1 if true 0 otherwise
2536
 */
2537
int
2538
xmlUCSIsTibetan(int code) {
2539
    return(((code >= 0x0F00) && (code <= 0x0FFF)));
2540
}
2541

2542
/**
2543
 * xmlUCSIsUgaritic:
2544
 * @code: UCS code point
2545
 *
2546
 * Check whether the character is part of Ugaritic UCS Block
2547
 *
2548
 * Returns 1 if true 0 otherwise
2549
 */
2550
int
2551
xmlUCSIsUgaritic(int code) {
2552
    return(((code >= 0x10380) && (code <= 0x1039F)));
2553
}
2554

2555
/**
2556
 * xmlUCSIsUnifiedCanadianAboriginalSyllabics:
2557
 * @code: UCS code point
2558
 *
2559
 * Check whether the character is part of UnifiedCanadianAboriginalSyllabics UCS Block
2560
 *
2561
 * Returns 1 if true 0 otherwise
2562
 */
2563
int
2564
xmlUCSIsUnifiedCanadianAboriginalSyllabics(int code) {
2565
    return(((code >= 0x1400) && (code <= 0x167F)));
2566
}
2567

2568
/**
2569
 * xmlUCSIsVariationSelectors:
2570
 * @code: UCS code point
2571
 *
2572
 * Check whether the character is part of VariationSelectors UCS Block
2573
 *
2574
 * Returns 1 if true 0 otherwise
2575
 */
2576
int
2577
xmlUCSIsVariationSelectors(int code) {
2578
    return(((code >= 0xFE00) && (code <= 0xFE0F)));
2579
}
2580

2581
/**
2582
 * xmlUCSIsVariationSelectorsSupplement:
2583
 * @code: UCS code point
2584
 *
2585
 * Check whether the character is part of VariationSelectorsSupplement UCS Block
2586
 *
2587
 * Returns 1 if true 0 otherwise
2588
 */
2589
int
2590
xmlUCSIsVariationSelectorsSupplement(int code) {
2591
    return(((code >= 0xE0100) && (code <= 0xE01EF)));
2592
}
2593

2594
/**
2595
 * xmlUCSIsYiRadicals:
2596
 * @code: UCS code point
2597
 *
2598
 * Check whether the character is part of YiRadicals UCS Block
2599
 *
2600
 * Returns 1 if true 0 otherwise
2601
 */
2602
int
2603
xmlUCSIsYiRadicals(int code) {
2604
    return(((code >= 0xA490) && (code <= 0xA4CF)));
2605
}
2606

2607
/**
2608
 * xmlUCSIsYiSyllables:
2609
 * @code: UCS code point
2610
 *
2611
 * Check whether the character is part of YiSyllables UCS Block
2612
 *
2613
 * Returns 1 if true 0 otherwise
2614
 */
2615
int
2616
xmlUCSIsYiSyllables(int code) {
2617
    return(((code >= 0xA000) && (code <= 0xA48F)));
2618
}
2619

2620
/**
2621
 * xmlUCSIsYijingHexagramSymbols:
2622
 * @code: UCS code point
2623
 *
2624
 * Check whether the character is part of YijingHexagramSymbols UCS Block
2625
 *
2626
 * Returns 1 if true 0 otherwise
2627
 */
2628
int
2629
xmlUCSIsYijingHexagramSymbols(int code) {
2630
    return(((code >= 0x4DC0) && (code <= 0x4DFF)));
2631
}
2632

2633
/**
2634
 * xmlUCSIsBlock:
2635
 * @code: UCS code point
2636
 * @block: UCS block name
2637
 *
2638
 * Check whether the character is part of the UCS Block
2639
 *
2640
 * Returns 1 if true, 0 if false and -1 on unknown block
2641
 */
2642
int
2643
xmlUCSIsBlock(int code, const char *block) {
2644
    xmlIntFunc *func;
2645

2646
    func = xmlUnicodeLookup(&xmlUnicodeBlockTbl, block);
2647
    if (func == NULL)
2648
	return (-1);
2649
    return (func(code));
2650
}
2651

2652
/**
2653
 * xmlUCSIsCatC:
2654
 * @code: UCS code point
2655
 *
2656
 * Check whether the character is part of C UCS Category
2657
 *
2658
 * Returns 1 if true 0 otherwise
2659
 */
2660
int
2661
xmlUCSIsCatC(int code) {
2662
    return(xmlCharInRange((unsigned int)code, &xmlCG));
2663
}
2664

2665
/**
2666
 * xmlUCSIsCatCc:
2667
 * @code: UCS code point
2668
 *
2669
 * Check whether the character is part of Cc UCS Category
2670
 *
2671
 * Returns 1 if true 0 otherwise
2672
 */
2673
int
2674
xmlUCSIsCatCc(int code) {
2675
    return(((code >= 0x0) && (code <= 0x1f)) ||
2676
           ((code >= 0x7f) && (code <= 0x9f)));
2677
}
2678

2679
/**
2680
 * xmlUCSIsCatCf:
2681
 * @code: UCS code point
2682
 *
2683
 * Check whether the character is part of Cf UCS Category
2684
 *
2685
 * Returns 1 if true 0 otherwise
2686
 */
2687
int
2688
xmlUCSIsCatCf(int code) {
2689
    return(xmlCharInRange((unsigned int)code, &xmlCfG));
2690
}
2691

2692
/**
2693
 * xmlUCSIsCatCo:
2694
 * @code: UCS code point
2695
 *
2696
 * Check whether the character is part of Co UCS Category
2697
 *
2698
 * Returns 1 if true 0 otherwise
2699
 */
2700
int
2701
xmlUCSIsCatCo(int code) {
2702
    return((code == 0xe000) ||
2703
           (code == 0xf8ff) ||
2704
           (code == 0xf0000) ||
2705
           (code == 0xffffd) ||
2706
           (code == 0x100000) ||
2707
           (code == 0x10fffd));
2708
}
2709

2710
/**
2711
 * xmlUCSIsCatCs:
2712
 * @code: UCS code point
2713
 *
2714
 * Check whether the character is part of Cs UCS Category
2715
 *
2716
 * Returns 1 if true 0 otherwise
2717
 */
2718
int
2719
xmlUCSIsCatCs(int code) {
2720
    return((code == 0xd800) ||
2721
           ((code >= 0xdb7f) && (code <= 0xdb80)) ||
2722
           ((code >= 0xdbff) && (code <= 0xdc00)) ||
2723
           (code == 0xdfff));
2724
}
2725

2726
/**
2727
 * xmlUCSIsCatL:
2728
 * @code: UCS code point
2729
 *
2730
 * Check whether the character is part of L UCS Category
2731
 *
2732
 * Returns 1 if true 0 otherwise
2733
 */
2734
int
2735
xmlUCSIsCatL(int code) {
2736
    return(xmlCharInRange((unsigned int)code, &xmlLG));
2737
}
2738

2739
/**
2740
 * xmlUCSIsCatLl:
2741
 * @code: UCS code point
2742
 *
2743
 * Check whether the character is part of Ll UCS Category
2744
 *
2745
 * Returns 1 if true 0 otherwise
2746
 */
2747
int
2748
xmlUCSIsCatLl(int code) {
2749
    return(xmlCharInRange((unsigned int)code, &xmlLlG));
2750
}
2751

2752
/**
2753
 * xmlUCSIsCatLm:
2754
 * @code: UCS code point
2755
 *
2756
 * Check whether the character is part of Lm UCS Category
2757
 *
2758
 * Returns 1 if true 0 otherwise
2759
 */
2760
int
2761
xmlUCSIsCatLm(int code) {
2762
    return(xmlCharInRange((unsigned int)code, &xmlLmG));
2763
}
2764

2765
/**
2766
 * xmlUCSIsCatLo:
2767
 * @code: UCS code point
2768
 *
2769
 * Check whether the character is part of Lo UCS Category
2770
 *
2771
 * Returns 1 if true 0 otherwise
2772
 */
2773
int
2774
xmlUCSIsCatLo(int code) {
2775
    return(xmlCharInRange((unsigned int)code, &xmlLoG));
2776
}
2777

2778
/**
2779
 * xmlUCSIsCatLt:
2780
 * @code: UCS code point
2781
 *
2782
 * Check whether the character is part of Lt UCS Category
2783
 *
2784
 * Returns 1 if true 0 otherwise
2785
 */
2786
int
2787
xmlUCSIsCatLt(int code) {
2788
    return(xmlCharInRange((unsigned int)code, &xmlLtG));
2789
}
2790

2791
/**
2792
 * xmlUCSIsCatLu:
2793
 * @code: UCS code point
2794
 *
2795
 * Check whether the character is part of Lu UCS Category
2796
 *
2797
 * Returns 1 if true 0 otherwise
2798
 */
2799
int
2800
xmlUCSIsCatLu(int code) {
2801
    return(xmlCharInRange((unsigned int)code, &xmlLuG));
2802
}
2803

2804
/**
2805
 * xmlUCSIsCatM:
2806
 * @code: UCS code point
2807
 *
2808
 * Check whether the character is part of M UCS Category
2809
 *
2810
 * Returns 1 if true 0 otherwise
2811
 */
2812
int
2813
xmlUCSIsCatM(int code) {
2814
    return(xmlCharInRange((unsigned int)code, &xmlMG));
2815
}
2816

2817
/**
2818
 * xmlUCSIsCatMc:
2819
 * @code: UCS code point
2820
 *
2821
 * Check whether the character is part of Mc UCS Category
2822
 *
2823
 * Returns 1 if true 0 otherwise
2824
 */
2825
int
2826
xmlUCSIsCatMc(int code) {
2827
    return(xmlCharInRange((unsigned int)code, &xmlMcG));
2828
}
2829

2830
/**
2831
 * xmlUCSIsCatMe:
2832
 * @code: UCS code point
2833
 *
2834
 * Check whether the character is part of Me UCS Category
2835
 *
2836
 * Returns 1 if true 0 otherwise
2837
 */
2838
int
2839
xmlUCSIsCatMe(int code) {
2840
    return(((code >= 0x488) && (code <= 0x489)) ||
2841
           (code == 0x6de) ||
2842
           ((code >= 0x20dd) && (code <= 0x20e0)) ||
2843
           ((code >= 0x20e2) && (code <= 0x20e4)));
2844
}
2845

2846
/**
2847
 * xmlUCSIsCatMn:
2848
 * @code: UCS code point
2849
 *
2850
 * Check whether the character is part of Mn UCS Category
2851
 *
2852
 * Returns 1 if true 0 otherwise
2853
 */
2854
int
2855
xmlUCSIsCatMn(int code) {
2856
    return(xmlCharInRange((unsigned int)code, &xmlMnG));
2857
}
2858

2859
/**
2860
 * xmlUCSIsCatN:
2861
 * @code: UCS code point
2862
 *
2863
 * Check whether the character is part of N UCS Category
2864
 *
2865
 * Returns 1 if true 0 otherwise
2866
 */
2867
int
2868
xmlUCSIsCatN(int code) {
2869
    return(xmlCharInRange((unsigned int)code, &xmlNG));
2870
}
2871

2872
/**
2873
 * xmlUCSIsCatNd:
2874
 * @code: UCS code point
2875
 *
2876
 * Check whether the character is part of Nd UCS Category
2877
 *
2878
 * Returns 1 if true 0 otherwise
2879
 */
2880
int
2881
xmlUCSIsCatNd(int code) {
2882
    return(xmlCharInRange((unsigned int)code, &xmlNdG));
2883
}
2884

2885
/**
2886
 * xmlUCSIsCatNl:
2887
 * @code: UCS code point
2888
 *
2889
 * Check whether the character is part of Nl UCS Category
2890
 *
2891
 * Returns 1 if true 0 otherwise
2892
 */
2893
int
2894
xmlUCSIsCatNl(int code) {
2895
    return(((code >= 0x16ee) && (code <= 0x16f0)) ||
2896
           ((code >= 0x2160) && (code <= 0x2183)) ||
2897
           (code == 0x3007) ||
2898
           ((code >= 0x3021) && (code <= 0x3029)) ||
2899
           ((code >= 0x3038) && (code <= 0x303a)) ||
2900
           (code == 0x1034a));
2901
}
2902

2903
/**
2904
 * xmlUCSIsCatNo:
2905
 * @code: UCS code point
2906
 *
2907
 * Check whether the character is part of No UCS Category
2908
 *
2909
 * Returns 1 if true 0 otherwise
2910
 */
2911
int
2912
xmlUCSIsCatNo(int code) {
2913
    return(xmlCharInRange((unsigned int)code, &xmlNoG));
2914
}
2915

2916
/**
2917
 * xmlUCSIsCatP:
2918
 * @code: UCS code point
2919
 *
2920
 * Check whether the character is part of P UCS Category
2921
 *
2922
 * Returns 1 if true 0 otherwise
2923
 */
2924
int
2925
xmlUCSIsCatP(int code) {
2926
    return(xmlCharInRange((unsigned int)code, &xmlPG));
2927
}
2928

2929
/**
2930
 * xmlUCSIsCatPc:
2931
 * @code: UCS code point
2932
 *
2933
 * Check whether the character is part of Pc UCS Category
2934
 *
2935
 * Returns 1 if true 0 otherwise
2936
 */
2937
int
2938
xmlUCSIsCatPc(int code) {
2939
    return((code == 0x5f) ||
2940
           ((code >= 0x203f) && (code <= 0x2040)) ||
2941
           (code == 0x2054) ||
2942
           (code == 0x30fb) ||
2943
           ((code >= 0xfe33) && (code <= 0xfe34)) ||
2944
           ((code >= 0xfe4d) && (code <= 0xfe4f)) ||
2945
           (code == 0xff3f) ||
2946
           (code == 0xff65));
2947
}
2948

2949
/**
2950
 * xmlUCSIsCatPd:
2951
 * @code: UCS code point
2952
 *
2953
 * Check whether the character is part of Pd UCS Category
2954
 *
2955
 * Returns 1 if true 0 otherwise
2956
 */
2957
int
2958
xmlUCSIsCatPd(int code) {
2959
    return(xmlCharInRange((unsigned int)code, &xmlPdG));
2960
}
2961

2962
/**
2963
 * xmlUCSIsCatPe:
2964
 * @code: UCS code point
2965
 *
2966
 * Check whether the character is part of Pe UCS Category
2967
 *
2968
 * Returns 1 if true 0 otherwise
2969
 */
2970
int
2971
xmlUCSIsCatPe(int code) {
2972
    return(xmlCharInRange((unsigned int)code, &xmlPeG));
2973
}
2974

2975
/**
2976
 * xmlUCSIsCatPf:
2977
 * @code: UCS code point
2978
 *
2979
 * Check whether the character is part of Pf UCS Category
2980
 *
2981
 * Returns 1 if true 0 otherwise
2982
 */
2983
int
2984
xmlUCSIsCatPf(int code) {
2985
    return((code == 0xbb) ||
2986
           (code == 0x2019) ||
2987
           (code == 0x201d) ||
2988
           (code == 0x203a));
2989
}
2990

2991
/**
2992
 * xmlUCSIsCatPi:
2993
 * @code: UCS code point
2994
 *
2995
 * Check whether the character is part of Pi UCS Category
2996
 *
2997
 * Returns 1 if true 0 otherwise
2998
 */
2999
int
3000
xmlUCSIsCatPi(int code) {
3001
    return((code == 0xab) ||
3002
           (code == 0x2018) ||
3003
           ((code >= 0x201b) && (code <= 0x201c)) ||
3004
           (code == 0x201f) ||
3005
           (code == 0x2039));
3006
}
3007

3008
/**
3009
 * xmlUCSIsCatPo:
3010
 * @code: UCS code point
3011
 *
3012
 * Check whether the character is part of Po UCS Category
3013
 *
3014
 * Returns 1 if true 0 otherwise
3015
 */
3016
int
3017
xmlUCSIsCatPo(int code) {
3018
    return(xmlCharInRange((unsigned int)code, &xmlPoG));
3019
}
3020

3021
/**
3022
 * xmlUCSIsCatPs:
3023
 * @code: UCS code point
3024
 *
3025
 * Check whether the character is part of Ps UCS Category
3026
 *
3027
 * Returns 1 if true 0 otherwise
3028
 */
3029
int
3030
xmlUCSIsCatPs(int code) {
3031
    return(xmlCharInRange((unsigned int)code, &xmlPsG));
3032
}
3033

3034
/**
3035
 * xmlUCSIsCatS:
3036
 * @code: UCS code point
3037
 *
3038
 * Check whether the character is part of S UCS Category
3039
 *
3040
 * Returns 1 if true 0 otherwise
3041
 */
3042
int
3043
xmlUCSIsCatS(int code) {
3044
    return(xmlCharInRange((unsigned int)code, &xmlSG));
3045
}
3046

3047
/**
3048
 * xmlUCSIsCatSc:
3049
 * @code: UCS code point
3050
 *
3051
 * Check whether the character is part of Sc UCS Category
3052
 *
3053
 * Returns 1 if true 0 otherwise
3054
 */
3055
int
3056
xmlUCSIsCatSc(int code) {
3057
    return(xmlCharInRange((unsigned int)code, &xmlScG));
3058
}
3059

3060
/**
3061
 * xmlUCSIsCatSk:
3062
 * @code: UCS code point
3063
 *
3064
 * Check whether the character is part of Sk UCS Category
3065
 *
3066
 * Returns 1 if true 0 otherwise
3067
 */
3068
int
3069
xmlUCSIsCatSk(int code) {
3070
    return(xmlCharInRange((unsigned int)code, &xmlSkG));
3071
}
3072

3073
/**
3074
 * xmlUCSIsCatSm:
3075
 * @code: UCS code point
3076
 *
3077
 * Check whether the character is part of Sm UCS Category
3078
 *
3079
 * Returns 1 if true 0 otherwise
3080
 */
3081
int
3082
xmlUCSIsCatSm(int code) {
3083
    return(xmlCharInRange((unsigned int)code, &xmlSmG));
3084
}
3085

3086
/**
3087
 * xmlUCSIsCatSo:
3088
 * @code: UCS code point
3089
 *
3090
 * Check whether the character is part of So UCS Category
3091
 *
3092
 * Returns 1 if true 0 otherwise
3093
 */
3094
int
3095
xmlUCSIsCatSo(int code) {
3096
    return(xmlCharInRange((unsigned int)code, &xmlSoG));
3097
}
3098

3099
/**
3100
 * xmlUCSIsCatZ:
3101
 * @code: UCS code point
3102
 *
3103
 * Check whether the character is part of Z UCS Category
3104
 *
3105
 * Returns 1 if true 0 otherwise
3106
 */
3107
int
3108
xmlUCSIsCatZ(int code) {
3109
    return(xmlCharInRange((unsigned int)code, &xmlZG));
3110
}
3111

3112
/**
3113
 * xmlUCSIsCatZl:
3114
 * @code: UCS code point
3115
 *
3116
 * Check whether the character is part of Zl UCS Category
3117
 *
3118
 * Returns 1 if true 0 otherwise
3119
 */
3120
int
3121
xmlUCSIsCatZl(int code) {
3122
    return((code == 0x2028));
3123
}
3124

3125
/**
3126
 * xmlUCSIsCatZp:
3127
 * @code: UCS code point
3128
 *
3129
 * Check whether the character is part of Zp UCS Category
3130
 *
3131
 * Returns 1 if true 0 otherwise
3132
 */
3133
int
3134
xmlUCSIsCatZp(int code) {
3135
    return((code == 0x2029));
3136
}
3137

3138
/**
3139
 * xmlUCSIsCatZs:
3140
 * @code: UCS code point
3141
 *
3142
 * Check whether the character is part of Zs UCS Category
3143
 *
3144
 * Returns 1 if true 0 otherwise
3145
 */
3146
int
3147
xmlUCSIsCatZs(int code) {
3148
    return((code == 0x20) ||
3149
           (code == 0xa0) ||
3150
           (code == 0x1680) ||
3151
           (code == 0x180e) ||
3152
           ((code >= 0x2000) && (code <= 0x200a)) ||
3153
           (code == 0x202f) ||
3154
           (code == 0x205f) ||
3155
           (code == 0x3000));
3156
}
3157

3158
/**
3159
 * xmlUCSIsCat:
3160
 * @code: UCS code point
3161
 * @cat: UCS Category name
3162
 *
3163
 * Check whether the character is part of the UCS Category
3164
 *
3165
 * Returns 1 if true, 0 if false and -1 on unknown category
3166
 */
3167
int
3168
xmlUCSIsCat(int code, const char *cat) {
3169
    xmlIntFunc *func;
3170

3171
    func = xmlUnicodeLookup(&xmlUnicodeCatTbl, cat);
3172
    if (func == NULL)
3173
	return (-1);
3174
    return (func(code));
3175
}
3176

3177
#endif /* LIBXML_UNICODE_ENABLED */
3178

3179
Product

Resources

Company
