gnulib-local/lib/libxml/xmlunicode.c

   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 <veillard@redhat.com>
  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     xmlUnicodeRange *table;
  33     int             numentries;
  34 } xmlUnicodeNameTable;
  35
  36
  37 static xmlIntFunc *xmlUnicodeLookup(xmlUnicodeNameTable *tptr, const char *tname);
  38
  39 static 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 xmlChRangeGroup xmlZG = {9,0,xmlZS,NULL};
 932
 933 static xmlUnicodeNameTable xmlUnicodeBlockTbl = {xmlUnicodeBlocks, 128};
 934 static 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(xmlUnicodeNameTable *tptr, const char *tname) {
 947     int low, high, mid, cmp;
 948     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 #define bottom_xmlunicode
3178 #include "elfgcchack.h"
3179 #endif /* LIBXML_UNICODE_ENABLED */