00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00036
00037
00038
00039
00040
00041
00042
00043
00044 #include "BLOCXX_config.h"
00045 #include "UTF8Utils.hpp"
00046 #include "String.hpp"
00047 #include "Assertion.hpp"
00048 #include "Array.hpp"
00049 #include "Format.hpp"
00050 #include "ExceptionIds.hpp"
00051
00052 #include <string.h>
00053 #include <algorithm>
00054
00055 namespace BLOCXX_NAMESPACE
00056 {
00057
00058 BLOCXX_DEFINE_EXCEPTION_WITH_ID(InvalidUTF8);
00059
00060 namespace UTF8Utils
00061 {
00062 namespace {
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082 UInt8 SequenceLengthTable[256] =
00083 {
00084 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00085 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00086 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00087 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00088 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00089 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00090 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00091 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00092 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00093 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00094 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00095 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00096 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00097 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00098 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00099 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
00100 };
00101 }
00102 size_t charCount(const char* utf8str)
00103 {
00104 BLOCXX_ASSERT(utf8str != 0);
00105 const char* p = utf8str;
00106 size_t count = 0;
00107 while (*p)
00108 {
00109
00110 UInt8 c = static_cast<UInt8>(*p);
00111 if (c < 0x80 || c > 0xBF)
00112 {
00113 ++count;
00114 }
00115 ++p;
00116 }
00117 return count;
00118 }
00120 UInt16 UTF8toUCS2(const char* utf8char)
00121 {
00122 UInt32 c = UTF8toUCS4(utf8char);
00123 if (c > 0xFFFF)
00124 {
00125 return 0xFFFF;
00126 }
00127 else
00128 {
00129 return static_cast<UInt16>(c);
00130 }
00131 }
00133 String UCS2toUTF8(UInt16 ucs2char)
00134 {
00135
00136 return UCS4toUTF8(ucs2char);
00137 }
00139 UInt32 UTF8toUCS4(const char* utf8char)
00140 {
00141 BLOCXX_ASSERT(utf8char != 0);
00142 BLOCXX_ASSERT(utf8char[0] != '\0');
00143 const char* p = utf8char;
00144 const UInt32 c0 = static_cast<UInt8>(p[0]);
00145 const UInt32 bad = 0xFFFFFFFF;
00146 switch (SequenceLengthTable[c0])
00147 {
00148 case 1:
00149 {
00150 return c0;
00151 }
00152 case 2:
00153 {
00154
00155 if (p[1] == '\0')
00156 {
00157 return bad;
00158 }
00159 const UInt32 c1 = static_cast<UInt8>(p[1]);
00160 return ((c0 & 0x1fu) << 6) | (c1 & 0x3fu);
00161 }
00162 case 3:
00163 {
00164
00165 if (p[1] == '\0' || p[2] == '\0')
00166 {
00167 return bad;
00168 }
00169 const UInt32 c1 = static_cast<UInt8>(p[1]);
00170 const UInt32 c2 = static_cast<UInt8>(p[2]);
00171 return ((c0 & 0x0fu) << 12) | ((c1 & 0x3fu) << 6) | (c2 & 0x3fu);
00172 }
00173 case 4:
00174 {
00175
00176 if (p[1] == '\0' || p[2] == '\0' || p[3] == '\0')
00177 {
00178 return bad;
00179 }
00180
00181 const UInt32 c1 = static_cast<UInt8>(p[1]);
00182 const UInt32 c2 = static_cast<UInt8>(p[2]);
00183 const UInt32 c3 = static_cast<UInt8>(p[3]);
00184
00185 return ((c0 & 0x03u) << 18) | ((c1 & 0x3fu) << 12) | ((c2 & 0x3fu) << 6) | (c3 & 0x3fu);
00186 }
00187 default:
00188 {
00189
00190 break;
00191 }
00192 }
00193 return bad;
00194 }
00195
00197 String UCS4toUTF8(UInt32 ucs4char)
00198 {
00199 StringBuffer sb(5);
00200 UCS4toUTF8(ucs4char, sb);
00201 return sb.releaseString();
00202 }
00203
00205 void UCS4toUTF8(UInt32 ucs4char, StringBuffer& sb)
00206 {
00207 if (ucs4char < 0x80u)
00208 {
00209
00210 sb += static_cast<char>(static_cast<UInt8>(ucs4char));
00211 }
00212 else if (ucs4char < 0x800u)
00213 {
00214 sb += static_cast<char>(static_cast<UInt8>(0xc0u | (ucs4char >> 6)));
00215 sb += static_cast<char>(static_cast<UInt8>(0x80u | (ucs4char & 0x3fu)));
00216 }
00217 else if (ucs4char < 0x10000u)
00218 {
00219 sb += static_cast<char>(static_cast<UInt8>(0xe0u | (ucs4char >> 12)));
00220 sb += static_cast<char>(static_cast<UInt8>(0x80u | ((ucs4char >> 6) & 0x3fu)));
00221 sb += static_cast<char>(static_cast<UInt8>(0x80u | (ucs4char & 0x3fu)));
00222 }
00223 else
00224 {
00225 sb += static_cast<char>(static_cast<UInt8>(0xf0u | (ucs4char >> 18)));
00226 sb += static_cast<char>(static_cast<UInt8>(0x80u | ((ucs4char >> 12) & 0x3fu)));
00227 sb += static_cast<char>(static_cast<UInt8>(0x80u | ((ucs4char >> 6) & 0x3fu)));
00228 sb += static_cast<char>(static_cast<UInt8>(0x80u | (ucs4char & 0x3fu)));
00229 }
00230 }
00231
00232 namespace
00233 {
00235 void UCS4toUTF8(UInt32 ucs4char, char* p)
00236 {
00237 if (ucs4char < 0x80u)
00238 {
00239
00240 p[0] = static_cast<char>(static_cast<UInt8>(ucs4char));
00241 }
00242 else if (ucs4char < 0x800u)
00243 {
00244 p[0] = static_cast<char>(static_cast<UInt8>(0xc0u | (ucs4char >> 6)));
00245 p[1] = static_cast<char>(static_cast<UInt8>(0x80u | (ucs4char & 0x3fu)));
00246 }
00247 else if (ucs4char < 0x10000u)
00248 {
00249 p[0] = static_cast<char>(static_cast<UInt8>(0xe0u | (ucs4char >> 12)));
00250 p[1] = static_cast<char>(static_cast<UInt8>(0x80u | ((ucs4char >> 6) & 0x3fu)));
00251 p[2] = static_cast<char>(static_cast<UInt8>(0x80u | (ucs4char & 0x3fu)));
00252 }
00253 else
00254 {
00255 p[0] = static_cast<char>(static_cast<UInt8>(0xf0u | (ucs4char >> 18)));
00256 p[1] = static_cast<char>(static_cast<UInt8>(0x80u | ((ucs4char >> 12) & 0x3fu)));
00257 p[2] = static_cast<char>(static_cast<UInt8>(0x80u | ((ucs4char >> 6) & 0x3fu)));
00258 p[3] = static_cast<char>(static_cast<UInt8>(0x80u | (ucs4char & 0x3fu)));
00259 }
00260 }
00261
00263 Array<UInt16> StringToUCS2Common(const String& input, bool throwException)
00264 {
00265
00266 Array<UInt16> rval;
00267 BLOCXX_ASSERT(input.length() == ::strlen(input.c_str()));
00268 const UInt16 UCS2ReplacementChar = 0xFFFD;
00269 const char* begin = input.c_str();
00270 const char* end = begin + input.length();
00271
00272 const char* p = begin;
00273 while (p < end)
00274 {
00275 const UInt32 c0 = static_cast<UInt8>(p[0]);
00276 switch (SequenceLengthTable[c0])
00277 {
00278 case 1:
00279 {
00280 rval.push_back(c0);
00281 ++p;
00282 }
00283 break;
00284 case 2:
00285 {
00286
00287 if (p[1] == '\0')
00288 {
00289 if (throwException)
00290 {
00291 BLOCXX_THROW(InvalidUTF8Exception, Format("Length: %1, input = %2, p = %3",
00292 static_cast<int>(SequenceLengthTable[c0]), input.c_str(), p).c_str());
00293 }
00294 else
00295 {
00296 rval.push_back(UCS2ReplacementChar);
00297 p += 2;
00298 }
00299 }
00300 const UInt32 c1 = static_cast<UInt8>(p[1]);
00301 rval.push_back(((c0 & 0x1fu) << 6) | (c1 & 0x3fu));
00302 p += 2;
00303 }
00304 break;
00305 case 3:
00306 {
00307
00308 if (p[1] == '\0' || p[2] == '\0')
00309 {
00310 if (throwException)
00311 {
00312 BLOCXX_THROW(InvalidUTF8Exception, Format("Length: %1, input = %2, p = %3",
00313 static_cast<int>(SequenceLengthTable[c0]), input.c_str(), p).c_str());
00314 }
00315 else
00316 {
00317 rval.push_back(UCS2ReplacementChar);
00318 p += 3;
00319 }
00320
00321 }
00322 const UInt32 c1 = static_cast<UInt8>(p[1]);
00323 const UInt32 c2 = static_cast<UInt8>(p[2]);
00324 rval.push_back(((c0 & 0x0fu) << 12) | ((c1 & 0x3fu) << 6) | (c2 & 0x3fu));
00325 p += 3;
00326 }
00327 break;
00328 case 4:
00329 {
00330
00331 if (throwException)
00332 {
00333 BLOCXX_THROW(InvalidUTF8Exception, Format("Length: %1, input = %2, p = %3",
00334 static_cast<int>(SequenceLengthTable[c0]), input.c_str(), p).c_str());
00335 }
00336 else
00337 {
00338 rval.push_back(UCS2ReplacementChar);
00339 p += 4;
00340 }
00341
00342 }
00343 break;
00344 default:
00345 {
00346 if (throwException)
00347 {
00348 BLOCXX_THROW(InvalidUTF8Exception, Format("Length: %1, input = %2, p = %3",
00349 static_cast<int>(SequenceLengthTable[c0]), input.c_str(), p).c_str());
00350 }
00351 else
00352 {
00353 rval.push_back(UCS2ReplacementChar);
00354 ++p;
00355 }
00356 }
00357 }
00358 }
00359 return rval;
00360 }
00361
00362 }
00363
00365 Array<UInt16> StringToUCS2ReplaceInvalid(const String& input)
00366 {
00367 return StringToUCS2Common(input, false);
00368 }
00369
00371 Array<UInt16> StringToUCS2(const String& input)
00372 {
00373 return StringToUCS2Common(input, true);
00374 }
00375
00377 String UCS2ToString(const void* input, size_t inputLength)
00378 {
00379
00380
00381
00382 size_t numchars = inputLength/2;
00383 StringBuffer sb(numchars + 1);
00384 for (size_t i = 0; i < numchars; ++i)
00385 {
00386 UCS4toUTF8(reinterpret_cast<const UInt16*>(input)[i], sb);
00387 }
00388 return sb.releaseString();
00389 }
00390
00392 String UCS2ToString(const Array<UInt16>& input)
00393 {
00394 return UCS2ToString(&input[0], input.size() * sizeof(UInt16));
00395 }
00397 String UCS2ToString(const Array<char>& input)
00398 {
00399 return UCS2ToString(&input[0], input.size());
00400 }
00401
00403 namespace
00404 {
00405
00406 int UTF8CharLen(UInt32 ucs4char)
00407 {
00408 if (ucs4char < 0x80u)
00409 {
00410 return 1;
00411 }
00412 else if (ucs4char < 0x800u)
00413 {
00414 return 2;
00415 }
00416 else if (ucs4char < 0x10000u)
00417 {
00418 return 3;
00419 }
00420 else
00421 {
00422 return 4;
00423 }
00424 }
00425
00426 template <typename TransformT>
00427 bool transformInPlace(char* input, TransformT transformer)
00428 {
00429 char* p = input;
00430 char* output = input;
00431 while (*p)
00432 {
00433 UInt32 ucs4char = UTF8toUCS4(p);
00434 if (ucs4char == 0xFFFFFFFF)
00435 {
00436 ++p;
00437 ++output;
00438 continue;
00439 }
00440 UInt32 newUcs4Char = transformer(ucs4char);
00441
00442 const UInt32 c0 = static_cast<UInt8>(p[0]);
00443 int prevCharLen = SequenceLengthTable[c0];
00444 int newCharLen = UTF8CharLen(newUcs4Char);
00445
00446
00447 if (p > output)
00448 {
00449 return false;
00450 }
00451
00452
00453
00454
00455
00456
00457
00458 UCS4toUTF8(newUcs4Char, output);
00459 p += prevCharLen;
00460 output += newCharLen;
00461 }
00462 *output = '\0';
00463 return true;
00464 }
00465
00466 template <typename TransformT>
00467 String transform(const char* input, TransformT transformer)
00468 {
00469 StringBuffer rval(strlen(input));
00470 const char* p = input;
00471 while (*p)
00472 {
00473 UInt32 ucs4char = UTF8toUCS4(p);
00474 if (ucs4char == 0xFFFFFFFF)
00475 {
00476 rval += *p;
00477 ++p;
00478 continue;
00479 }
00480
00481 UTF8Utils::UCS4toUTF8(transformer(ucs4char), rval);
00482
00483 const UInt32 c0 = static_cast<UInt8>(p[0]);
00484 int prevCharLen = SequenceLengthTable[c0];
00485 p += prevCharLen;
00486 }
00487 return rval.releaseString();
00488 }
00489
00490
00491
00492 struct CaseMapping
00493 {
00494 UInt32 codePoint;
00495 UInt32 mapping;
00496 };
00497 const CaseMapping lowerMappings[] =
00498 {
00499 {0x41, 0x61},
00500 {0x42, 0x62},
00501 {0x43, 0x63},
00502 {0x44, 0x64},
00503 {0x45, 0x65},
00504 {0x46, 0x66},
00505 {0x47, 0x67},
00506 {0x48, 0x68},
00507 {0x49, 0x69},
00508 {0x4a, 0x6a},
00509 {0x4b, 0x6b},
00510 {0x4c, 0x6c},
00511 {0x4d, 0x6d},
00512 {0x4e, 0x6e},
00513 {0x4f, 0x6f},
00514 {0x50, 0x70},
00515 {0x51, 0x71},
00516 {0x52, 0x72},
00517 {0x53, 0x73},
00518 {0x54, 0x74},
00519 {0x55, 0x75},
00520 {0x56, 0x76},
00521 {0x57, 0x77},
00522 {0x58, 0x78},
00523 {0x59, 0x79},
00524 {0x5a, 0x7a},
00525 {0xc0, 0xe0},
00526 {0xc1, 0xe1},
00527 {0xc2, 0xe2},
00528 {0xc3, 0xe3},
00529 {0xc4, 0xe4},
00530 {0xc5, 0xe5},
00531 {0xc6, 0xe6},
00532 {0xc7, 0xe7},
00533 {0xc8, 0xe8},
00534 {0xc9, 0xe9},
00535 {0xca, 0xea},
00536 {0xcb, 0xeb},
00537 {0xcc, 0xec},
00538 {0xcd, 0xed},
00539 {0xce, 0xee},
00540 {0xcf, 0xef},
00541 {0xd0, 0xf0},
00542 {0xd1, 0xf1},
00543 {0xd2, 0xf2},
00544 {0xd3, 0xf3},
00545 {0xd4, 0xf4},
00546 {0xd5, 0xf5},
00547 {0xd6, 0xf6},
00548 {0xd8, 0xf8},
00549 {0xd9, 0xf9},
00550 {0xda, 0xfa},
00551 {0xdb, 0xfb},
00552 {0xdc, 0xfc},
00553 {0xdd, 0xfd},
00554 {0xde, 0xfe},
00555 {0x100, 0x101},
00556 {0x102, 0x103},
00557 {0x104, 0x105},
00558 {0x106, 0x107},
00559 {0x108, 0x109},
00560 {0x10a, 0x10b},
00561 {0x10c, 0x10d},
00562 {0x10e, 0x10f},
00563 {0x110, 0x111},
00564 {0x112, 0x113},
00565 {0x114, 0x115},
00566 {0x116, 0x117},
00567 {0x118, 0x119},
00568 {0x11a, 0x11b},
00569 {0x11c, 0x11d},
00570 {0x11e, 0x11f},
00571 {0x120, 0x121},
00572 {0x122, 0x123},
00573 {0x124, 0x125},
00574 {0x126, 0x127},
00575 {0x128, 0x129},
00576 {0x12a, 0x12b},
00577 {0x12c, 0x12d},
00578 {0x12e, 0x12f},
00579 {0x130, 0x69},
00580 {0x132, 0x133},
00581 {0x134, 0x135},
00582 {0x136, 0x137},
00583 {0x139, 0x13a},
00584 {0x13b, 0x13c},
00585 {0x13d, 0x13e},
00586 {0x13f, 0x140},
00587 {0x141, 0x142},
00588 {0x143, 0x144},
00589 {0x145, 0x146},
00590 {0x147, 0x148},
00591 {0x14a, 0x14b},
00592 {0x14c, 0x14d},
00593 {0x14e, 0x14f},
00594 {0x150, 0x151},
00595 {0x152, 0x153},
00596 {0x154, 0x155},
00597 {0x156, 0x157},
00598 {0x158, 0x159},
00599 {0x15a, 0x15b},
00600 {0x15c, 0x15d},
00601 {0x15e, 0x15f},
00602 {0x160, 0x161},
00603 {0x162, 0x163},
00604 {0x164, 0x165},
00605 {0x166, 0x167},
00606 {0x168, 0x169},
00607 {0x16a, 0x16b},
00608 {0x16c, 0x16d},
00609 {0x16e, 0x16f},
00610 {0x170, 0x171},
00611 {0x172, 0x173},
00612 {0x174, 0x175},
00613 {0x176, 0x177},
00614 {0x178, 0xff},
00615 {0x179, 0x17a},
00616 {0x17b, 0x17c},
00617 {0x17d, 0x17e},
00618 {0x181, 0x253},
00619 {0x182, 0x183},
00620 {0x184, 0x185},
00621 {0x186, 0x254},
00622 {0x187, 0x188},
00623 {0x189, 0x256},
00624 {0x18a, 0x257},
00625 {0x18b, 0x18c},
00626 {0x18e, 0x1dd},
00627 {0x18f, 0x259},
00628 {0x190, 0x25b},
00629 {0x191, 0x192},
00630 {0x193, 0x260},
00631 {0x194, 0x263},
00632 {0x196, 0x269},
00633 {0x197, 0x268},
00634 {0x198, 0x199},
00635 {0x19c, 0x26f},
00636 {0x19d, 0x272},
00637 {0x19f, 0x275},
00638 {0x1a0, 0x1a1},
00639 {0x1a2, 0x1a3},
00640 {0x1a4, 0x1a5},
00641 {0x1a6, 0x280},
00642 {0x1a7, 0x1a8},
00643 {0x1a9, 0x283},
00644 {0x1ac, 0x1ad},
00645 {0x1ae, 0x288},
00646 {0x1af, 0x1b0},
00647 {0x1b1, 0x28a},
00648 {0x1b2, 0x28b},
00649 {0x1b3, 0x1b4},
00650 {0x1b5, 0x1b6},
00651 {0x1b7, 0x292},
00652 {0x1b8, 0x1b9},
00653 {0x1bc, 0x1bd},
00654 {0x1c4, 0x1c6},
00655 {0x1c5, 0x1c6},
00656 {0x1c7, 0x1c9},
00657 {0x1c8, 0x1c9},
00658 {0x1ca, 0x1cc},
00659 {0x1cb, 0x1cc},
00660 {0x1cd, 0x1ce},
00661 {0x1cf, 0x1d0},
00662 {0x1d1, 0x1d2},
00663 {0x1d3, 0x1d4},
00664 {0x1d5, 0x1d6},
00665 {0x1d7, 0x1d8},
00666 {0x1d9, 0x1da},
00667 {0x1db, 0x1dc},
00668 {0x1de, 0x1df},
00669 {0x1e0, 0x1e1},
00670 {0x1e2, 0x1e3},
00671 {0x1e4, 0x1e5},
00672 {0x1e6, 0x1e7},
00673 {0x1e8, 0x1e9},
00674 {0x1ea, 0x1eb},
00675 {0x1ec, 0x1ed},
00676 {0x1ee, 0x1ef},
00677 {0x1f1, 0x1f3},
00678 {0x1f2, 0x1f3},
00679 {0x1f4, 0x1f5},
00680 {0x1f6, 0x195},
00681 {0x1f7, 0x1bf},
00682 {0x1f8, 0x1f9},
00683 {0x1fa, 0x1fb},
00684 {0x1fc, 0x1fd},
00685 {0x1fe, 0x1ff},
00686 {0x200, 0x201},
00687 {0x202, 0x203},
00688 {0x204, 0x205},
00689 {0x206, 0x207},
00690 {0x208, 0x209},
00691 {0x20a, 0x20b},
00692 {0x20c, 0x20d},
00693 {0x20e, 0x20f},
00694 {0x210, 0x211},
00695 {0x212, 0x213},
00696 {0x214, 0x215},
00697 {0x216, 0x217},
00698 {0x218, 0x219},
00699 {0x21a, 0x21b},
00700 {0x21c, 0x21d},
00701 {0x21e, 0x21f},
00702 {0x220, 0x19e},
00703 {0x222, 0x223},
00704 {0x224, 0x225},
00705 {0x226, 0x227},
00706 {0x228, 0x229},
00707 {0x22a, 0x22b},
00708 {0x22c, 0x22d},
00709 {0x22e, 0x22f},
00710 {0x230, 0x231},
00711 {0x232, 0x233},
00712 {0x386, 0x3ac},
00713 {0x388, 0x3ad},
00714 {0x389, 0x3ae},
00715 {0x38a, 0x3af},
00716 {0x38c, 0x3cc},
00717 {0x38e, 0x3cd},
00718 {0x38f, 0x3ce},
00719 {0x391, 0x3b1},
00720 {0x392, 0x3b2},
00721 {0x393, 0x3b3},
00722 {0x394, 0x3b4},
00723 {0x395, 0x3b5},
00724 {0x396, 0x3b6},
00725 {0x397, 0x3b7},
00726 {0x398, 0x3b8},
00727 {0x399, 0x3b9},
00728 {0x39a, 0x3ba},
00729 {0x39b, 0x3bb},
00730 {0x39c, 0x3bc},
00731 {0x39d, 0x3bd},
00732 {0x39e, 0x3be},
00733 {0x39f, 0x3bf},
00734 {0x3a0, 0x3c0},
00735 {0x3a1, 0x3c1},
00736 {0x3a3, 0x3c3},
00737 {0x3a4, 0x3c4},
00738 {0x3a5, 0x3c5},
00739 {0x3a6, 0x3c6},
00740 {0x3a7, 0x3c7},
00741 {0x3a8, 0x3c8},
00742 {0x3a9, 0x3c9},
00743 {0x3aa, 0x3ca},
00744 {0x3ab, 0x3cb},
00745 {0x3d8, 0x3d9},
00746 {0x3da, 0x3db},
00747 {0x3dc, 0x3dd},
00748 {0x3de, 0x3df},
00749 {0x3e0, 0x3e1},
00750 {0x3e2, 0x3e3},
00751 {0x3e4, 0x3e5},
00752 {0x3e6, 0x3e7},
00753 {0x3e8, 0x3e9},
00754 {0x3ea, 0x3eb},
00755 {0x3ec, 0x3ed},
00756 {0x3ee, 0x3ef},
00757 {0x3f4, 0x3b8},
00758 {0x3f7, 0x3f8},
00759 {0x3f9, 0x3f2},
00760 {0x3fa, 0x3fb},
00761 {0x400, 0x450},
00762 {0x401, 0x451},
00763 {0x402, 0x452},
00764 {0x403, 0x453},
00765 {0x404, 0x454},
00766 {0x405, 0x455},
00767 {0x406, 0x456},
00768 {0x407, 0x457},
00769 {0x408, 0x458},
00770 {0x409, 0x459},
00771 {0x40a, 0x45a},
00772 {0x40b, 0x45b},
00773 {0x40c, 0x45c},
00774 {0x40d, 0x45d},
00775 {0x40e, 0x45e},
00776 {0x40f, 0x45f},
00777 {0x410, 0x430},
00778 {0x411, 0x431},
00779 {0x412, 0x432},
00780 {0x413, 0x433},
00781 {0x414, 0x434},
00782 {0x415, 0x435},
00783 {0x416, 0x436},
00784 {0x417, 0x437},
00785 {0x418, 0x438},
00786 {0x419, 0x439},
00787 {0x41a, 0x43a},
00788 {0x41b, 0x43b},
00789 {0x41c, 0x43c},
00790 {0x41d, 0x43d},
00791 {0x41e, 0x43e},
00792 {0x41f, 0x43f},
00793 {0x420, 0x440},
00794 {0x421, 0x441},
00795 {0x422, 0x442},
00796 {0x423, 0x443},
00797 {0x424, 0x444},
00798 {0x425, 0x445},
00799 {0x426, 0x446},
00800 {0x427, 0x447},
00801 {0x428, 0x448},
00802 {0x429, 0x449},
00803 {0x42a, 0x44a},
00804 {0x42b, 0x44b},
00805 {0x42c, 0x44c},
00806 {0x42d, 0x44d},
00807 {0x42e, 0x44e},
00808 {0x42f, 0x44f},
00809 {0x460, 0x461},
00810 {0x462, 0x463},
00811 {0x464, 0x465},
00812 {0x466, 0x467},
00813 {0x468, 0x469},
00814 {0x46a, 0x46b},
00815 {0x46c, 0x46d},
00816 {0x46e, 0x46f},
00817 {0x470, 0x471},
00818 {0x472, 0x473},
00819 {0x474, 0x475},
00820 {0x476, 0x477},
00821 {0x478, 0x479},
00822 {0x47a, 0x47b},
00823 {0x47c, 0x47d},
00824 {0x47e, 0x47f},
00825 {0x480, 0x481},
00826 {0x48a, 0x48b},
00827 {0x48c, 0x48d},
00828 {0x48e, 0x48f},
00829 {0x490, 0x491},
00830 {0x492, 0x493},
00831 {0x494, 0x495},
00832 {0x496, 0x497},
00833 {0x498, 0x499},
00834 {0x49a, 0x49b},
00835 {0x49c, 0x49d},
00836 {0x49e, 0x49f},
00837 {0x4a0, 0x4a1},
00838 {0x4a2, 0x4a3},
00839 {0x4a4, 0x4a5},
00840 {0x4a6, 0x4a7},
00841 {0x4a8, 0x4a9},
00842 {0x4aa, 0x4ab},
00843 {0x4ac, 0x4ad},
00844 {0x4ae, 0x4af},
00845 {0x4b0, 0x4b1},
00846 {0x4b2, 0x4b3},
00847 {0x4b4, 0x4b5},
00848 {0x4b6, 0x4b7},
00849 {0x4b8, 0x4b9},
00850 {0x4ba, 0x4bb},
00851 {0x4bc, 0x4bd},
00852 {0x4be, 0x4bf},
00853 {0x4c1, 0x4c2},
00854 {0x4c3, 0x4c4},
00855 {0x4c5, 0x4c6},
00856 {0x4c7, 0x4c8},
00857 {0x4c9, 0x4ca},
00858 {0x4cb, 0x4cc},
00859 {0x4cd, 0x4ce},
00860 {0x4d0, 0x4d1},
00861 {0x4d2, 0x4d3},
00862 {0x4d4, 0x4d5},
00863 {0x4d6, 0x4d7},
00864 {0x4d8, 0x4d9},
00865 {0x4da, 0x4db},
00866 {0x4dc, 0x4dd},
00867 {0x4de, 0x4df},
00868 {0x4e0, 0x4e1},
00869 {0x4e2, 0x4e3},
00870 {0x4e4, 0x4e5},
00871 {0x4e6, 0x4e7},
00872 {0x4e8, 0x4e9},
00873 {0x4ea, 0x4eb},
00874 {0x4ec, 0x4ed},
00875 {0x4ee, 0x4ef},
00876 {0x4f0, 0x4f1},
00877 {0x4f2, 0x4f3},
00878 {0x4f4, 0x4f5},
00879 {0x4f8, 0x4f9},
00880 {0x500, 0x501},
00881 {0x502, 0x503},
00882 {0x504, 0x505},
00883 {0x506, 0x507},
00884 {0x508, 0x509},
00885 {0x50a, 0x50b},
00886 {0x50c, 0x50d},
00887 {0x50e, 0x50f},
00888 {0x531, 0x561},
00889 {0x532, 0x562},
00890 {0x533, 0x563},
00891 {0x534, 0x564},
00892 {0x535, 0x565},
00893 {0x536, 0x566},
00894 {0x537, 0x567},
00895 {0x538, 0x568},
00896 {0x539, 0x569},
00897 {0x53a, 0x56a},
00898 {0x53b, 0x56b},
00899 {0x53c, 0x56c},
00900 {0x53d, 0x56d},
00901 {0x53e, 0x56e},
00902 {0x53f, 0x56f},
00903 {0x540, 0x570},
00904 {0x541, 0x571},
00905 {0x542, 0x572},
00906 {0x543, 0x573},
00907 {0x544, 0x574},
00908 {0x545, 0x575},
00909 {0x546, 0x576},
00910 {0x547, 0x577},
00911 {0x548, 0x578},
00912 {0x549, 0x579},
00913 {0x54a, 0x57a},
00914 {0x54b, 0x57b},
00915 {0x54c, 0x57c},
00916 {0x54d, 0x57d},
00917 {0x54e, 0x57e},
00918 {0x54f, 0x57f},
00919 {0x550, 0x580},
00920 {0x551, 0x581},
00921 {0x552, 0x582},
00922 {0x553, 0x583},
00923 {0x554, 0x584},
00924 {0x555, 0x585},
00925 {0x556, 0x586},
00926 {0x1e00, 0x1e01},
00927 {0x1e02, 0x1e03},
00928 {0x1e04, 0x1e05},
00929 {0x1e06, 0x1e07},
00930 {0x1e08, 0x1e09},
00931 {0x1e0a, 0x1e0b},
00932 {0x1e0c, 0x1e0d},
00933 {0x1e0e, 0x1e0f},
00934 {0x1e10, 0x1e11},
00935 {0x1e12, 0x1e13},
00936 {0x1e14, 0x1e15},
00937 {0x1e16, 0x1e17},
00938 {0x1e18, 0x1e19},
00939 {0x1e1a, 0x1e1b},
00940 {0x1e1c, 0x1e1d},
00941 {0x1e1e, 0x1e1f},
00942 {0x1e20, 0x1e21},
00943 {0x1e22, 0x1e23},
00944 {0x1e24, 0x1e25},
00945 {0x1e26, 0x1e27},
00946 {0x1e28, 0x1e29},
00947 {0x1e2a, 0x1e2b},
00948 {0x1e2c, 0x1e2d},
00949 {0x1e2e, 0x1e2f},
00950 {0x1e30, 0x1e31},
00951 {0x1e32, 0x1e33},
00952 {0x1e34, 0x1e35},
00953 {0x1e36, 0x1e37},
00954 {0x1e38, 0x1e39},
00955 {0x1e3a, 0x1e3b},
00956 {0x1e3c, 0x1e3d},
00957 {0x1e3e, 0x1e3f},
00958 {0x1e40, 0x1e41},
00959 {0x1e42, 0x1e43},
00960 {0x1e44, 0x1e45},
00961 {0x1e46, 0x1e47},
00962 {0x1e48, 0x1e49},
00963 {0x1e4a, 0x1e4b},
00964 {0x1e4c, 0x1e4d},
00965 {0x1e4e, 0x1e4f},
00966 {0x1e50, 0x1e51},
00967 {0x1e52, 0x1e53},
00968 {0x1e54, 0x1e55},
00969 {0x1e56, 0x1e57},
00970 {0x1e58, 0x1e59},
00971 {0x1e5a, 0x1e5b},
00972 {0x1e5c, 0x1e5d},
00973 {0x1e5e, 0x1e5f},
00974 {0x1e60, 0x1e61},
00975 {0x1e62, 0x1e63},
00976 {0x1e64, 0x1e65},
00977 {0x1e66, 0x1e67},
00978 {0x1e68, 0x1e69},
00979 {0x1e6a, 0x1e6b},
00980 {0x1e6c, 0x1e6d},
00981 {0x1e6e, 0x1e6f},
00982 {0x1e70, 0x1e71},
00983 {0x1e72, 0x1e73},
00984 {0x1e74, 0x1e75},
00985 {0x1e76, 0x1e77},
00986 {0x1e78, 0x1e79},
00987 {0x1e7a, 0x1e7b},
00988 {0x1e7c, 0x1e7d},
00989 {0x1e7e, 0x1e7f},
00990 {0x1e80, 0x1e81},
00991 {0x1e82, 0x1e83},
00992 {0x1e84, 0x1e85},
00993 {0x1e86, 0x1e87},
00994 {0x1e88, 0x1e89},
00995 {0x1e8a, 0x1e8b},
00996 {0x1e8c, 0x1e8d},
00997 {0x1e8e, 0x1e8f},
00998 {0x1e90, 0x1e91},
00999 {0x1e92, 0x1e93},
01000 {0x1e94, 0x1e95},
01001 {0x1ea0, 0x1ea1},
01002 {0x1ea2, 0x1ea3},
01003 {0x1ea4, 0x1ea5},
01004 {0x1ea6, 0x1ea7},
01005 {0x1ea8, 0x1ea9},
01006 {0x1eaa, 0x1eab},
01007 {0x1eac, 0x1ead},
01008 {0x1eae, 0x1eaf},
01009 {0x1eb0, 0x1eb1},
01010 {0x1eb2, 0x1eb3},
01011 {0x1eb4, 0x1eb5},
01012 {0x1eb6, 0x1eb7},
01013 {0x1eb8, 0x1eb9},
01014 {0x1eba, 0x1ebb},
01015 {0x1ebc, 0x1ebd},
01016 {0x1ebe, 0x1ebf},
01017 {0x1ec0, 0x1ec1},
01018 {0x1ec2, 0x1ec3},
01019 {0x1ec4, 0x1ec5},
01020 {0x1ec6, 0x1ec7},
01021 {0x1ec8, 0x1ec9},
01022 {0x1eca, 0x1ecb},
01023 {0x1ecc, 0x1ecd},
01024 {0x1ece, 0x1ecf},
01025 {0x1ed0, 0x1ed1},
01026 {0x1ed2, 0x1ed3},
01027 {0x1ed4, 0x1ed5},
01028 {0x1ed6, 0x1ed7},
01029 {0x1ed8, 0x1ed9},
01030 {0x1eda, 0x1edb},
01031 {0x1edc, 0x1edd},
01032 {0x1ede, 0x1edf},
01033 {0x1ee0, 0x1ee1},
01034 {0x1ee2, 0x1ee3},
01035 {0x1ee4, 0x1ee5},
01036 {0x1ee6, 0x1ee7},
01037 {0x1ee8, 0x1ee9},
01038 {0x1eea, 0x1eeb},
01039 {0x1eec, 0x1eed},
01040 {0x1eee, 0x1eef},
01041 {0x1ef0, 0x1ef1},
01042 {0x1ef2, 0x1ef3},
01043 {0x1ef4, 0x1ef5},
01044 {0x1ef6, 0x1ef7},
01045 {0x1ef8, 0x1ef9},
01046 {0x1f08, 0x1f00},
01047 {0x1f09, 0x1f01},
01048 {0x1f0a, 0x1f02},
01049 {0x1f0b, 0x1f03},
01050 {0x1f0c, 0x1f04},
01051 {0x1f0d, 0x1f05},
01052 {0x1f0e, 0x1f06},
01053 {0x1f0f, 0x1f07},
01054 {0x1f18, 0x1f10},
01055 {0x1f19, 0x1f11},
01056 {0x1f1a, 0x1f12},
01057 {0x1f1b, 0x1f13},
01058 {0x1f1c, 0x1f14},
01059 {0x1f1d, 0x1f15},
01060 {0x1f28, 0x1f20},
01061 {0x1f29, 0x1f21},
01062 {0x1f2a, 0x1f22},
01063 {0x1f2b, 0x1f23},
01064 {0x1f2c, 0x1f24},
01065 {0x1f2d, 0x1f25},
01066 {0x1f2e, 0x1f26},
01067 {0x1f2f, 0x1f27},
01068 {0x1f38, 0x1f30},
01069 {0x1f39, 0x1f31},
01070 {0x1f3a, 0x1f32},
01071 {0x1f3b, 0x1f33},
01072 {0x1f3c, 0x1f34},
01073 {0x1f3d, 0x1f35},
01074 {0x1f3e, 0x1f36},
01075 {0x1f3f, 0x1f37},
01076 {0x1f48, 0x1f40},
01077 {0x1f49, 0x1f41},
01078 {0x1f4a, 0x1f42},
01079 {0x1f4b, 0x1f43},
01080 {0x1f4c, 0x1f44},
01081 {0x1f4d, 0x1f45},
01082 {0x1f59, 0x1f51},
01083 {0x1f5b, 0x1f53},
01084 {0x1f5d, 0x1f55},
01085 {0x1f5f, 0x1f57},
01086 {0x1f68, 0x1f60},
01087 {0x1f69, 0x1f61},
01088 {0x1f6a, 0x1f62},
01089 {0x1f6b, 0x1f63},
01090 {0x1f6c, 0x1f64},
01091 {0x1f6d, 0x1f65},
01092 {0x1f6e, 0x1f66},
01093 {0x1f6f, 0x1f67},
01094 {0x1f88, 0x1f80},
01095 {0x1f89, 0x1f81},
01096 {0x1f8a, 0x1f82},
01097 {0x1f8b, 0x1f83},
01098 {0x1f8c, 0x1f84},
01099 {0x1f8d, 0x1f85},
01100 {0x1f8e, 0x1f86},
01101 {0x1f8f, 0x1f87},
01102 {0x1f98, 0x1f90},
01103 {0x1f99, 0x1f91},
01104 {0x1f9a, 0x1f92},
01105 {0x1f9b, 0x1f93},
01106 {0x1f9c, 0x1f94},
01107 {0x1f9d, 0x1f95},
01108 {0x1f9e, 0x1f96},
01109 {0x1f9f, 0x1f97},
01110 {0x1fa8, 0x1fa0},
01111 {0x1fa9, 0x1fa1},
01112 {0x1faa, 0x1fa2},
01113 {0x1fab, 0x1fa3},
01114 {0x1fac, 0x1fa4},
01115 {0x1fad, 0x1fa5},
01116 {0x1fae, 0x1fa6},
01117 {0x1faf, 0x1fa7},
01118 {0x1fb8, 0x1fb0},
01119 {0x1fb9, 0x1fb1},
01120 {0x1fba, 0x1f70},
01121 {0x1fbb, 0x1f71},
01122 {0x1fbc, 0x1fb3},
01123 {0x1fc8, 0x1f72},
01124 {0x1fc9, 0x1f73},
01125 {0x1fca, 0x1f74},
01126 {0x1fcb, 0x1f75},
01127 {0x1fcc, 0x1fc3},
01128 {0x1fd8, 0x1fd0},
01129 {0x1fd9, 0x1fd1},
01130 {0x1fda, 0x1f76},
01131 {0x1fdb, 0x1f77},
01132 {0x1fe8, 0x1fe0},
01133 {0x1fe9, 0x1fe1},
01134 {0x1fea, 0x1f7a},
01135 {0x1feb, 0x1f7b},
01136 {0x1fec, 0x1fe5},
01137 {0x1ff8, 0x1f78},
01138 {0x1ff9, 0x1f79},
01139 {0x1ffa, 0x1f7c},
01140 {0x1ffb, 0x1f7d},
01141 {0x1ffc, 0x1ff3},
01142 {0x2126, 0x3c9},
01143 {0x212a, 0x6b},
01144 {0x212b, 0xe5},
01145 {0x2160, 0x2170},
01146 {0x2161, 0x2171},
01147 {0x2162, 0x2172},
01148 {0x2163, 0x2173},
01149 {0x2164, 0x2174},
01150 {0x2165, 0x2175},
01151 {0x2166, 0x2176},
01152 {0x2167, 0x2177},
01153 {0x2168, 0x2178},
01154 {0x2169, 0x2179},
01155 {0x216a, 0x217a},
01156 {0x216b, 0x217b},
01157 {0x216c, 0x217c},
01158 {0x216d, 0x217d},
01159 {0x216e, 0x217e},
01160 {0x216f, 0x217f},
01161 {0x24b6, 0x24d0},
01162 {0x24b7, 0x24d1},
01163 {0x24b8, 0x24d2},
01164 {0x24b9, 0x24d3},
01165 {0x24ba, 0x24d4},
01166 {0x24bb, 0x24d5},
01167 {0x24bc, 0x24d6},
01168 {0x24bd, 0x24d7},
01169 {0x24be, 0x24d8},
01170 {0x24bf, 0x24d9},
01171 {0x24c0, 0x24da},
01172 {0x24c1, 0x24db},
01173 {0x24c2, 0x24dc},
01174 {0x24c3, 0x24dd},
01175 {0x24c4, 0x24de},
01176 {0x24c5, 0x24df},
01177 {0x24c6, 0x24e0},
01178 {0x24c7, 0x24e1},
01179 {0x24c8, 0x24e2},
01180 {0x24c9, 0x24e3},
01181 {0x24ca, 0x24e4},
01182 {0x24cb, 0x24e5},
01183 {0x24cc, 0x24e6},
01184 {0x24cd, 0x24e7},
01185 {0x24ce, 0x24e8},
01186 {0x24cf, 0x24e9},
01187 {0xff21, 0xff41},
01188 {0xff22, 0xff42},
01189 {0xff23, 0xff43},
01190 {0xff24, 0xff44},
01191 {0xff25, 0xff45},
01192 {0xff26, 0xff46},
01193 {0xff27, 0xff47},
01194 {0xff28, 0xff48},
01195 {0xff29, 0xff49},
01196 {0xff2a, 0xff4a},
01197 {0xff2b, 0xff4b},
01198 {0xff2c, 0xff4c},
01199 {0xff2d, 0xff4d},
01200 {0xff2e, 0xff4e},
01201 {0xff2f, 0xff4f},
01202 {0xff30, 0xff50},
01203 {0xff31, 0xff51},
01204 {0xff32, 0xff52},
01205 {0xff33, 0xff53},
01206 {0xff34, 0xff54},
01207 {0xff35, 0xff55},
01208 {0xff36, 0xff56},
01209 {0xff37, 0xff57},
01210 {0xff38, 0xff58},
01211 {0xff39, 0xff59},
01212 {0xff3a, 0xff5a},
01213 {0x10400, 0x10428},
01214 {0x10401, 0x10429},
01215 {0x10402, 0x1042a},
01216 {0x10403, 0x1042b},
01217 {0x10404, 0x1042c},
01218 {0x10405, 0x1042d},
01219 {0x10406, 0x1042e},
01220 {0x10407, 0x1042f},
01221 {0x10408, 0x10430},
01222 {0x10409, 0x10431},
01223 {0x1040a, 0x10432},
01224 {0x1040b, 0x10433},
01225 {0x1040c, 0x10434},
01226 {0x1040d, 0x10435},
01227 {0x1040e, 0x10436},
01228 {0x1040f, 0x10437},
01229 {0x10410, 0x10438},
01230 {0x10411, 0x10439},
01231 {0x10412, 0x1043a},
01232 {0x10413, 0x1043b},
01233 {0x10414, 0x1043c},
01234 {0x10415, 0x1043d},
01235 {0x10416, 0x1043e},
01236 {0x10417, 0x1043f},
01237 {0x10418, 0x10440},
01238 {0x10419, 0x10441},
01239 {0x1041a, 0x10442},
01240 {0x1041b, 0x10443},
01241 {0x1041c, 0x10444},
01242 {0x1041d, 0x10445},
01243 {0x1041e, 0x10446},
01244 {0x1041f, 0x10447},
01245 {0x10420, 0x10448},
01246 {0x10421, 0x10449},
01247 {0x10422, 0x1044a},
01248 {0x10423, 0x1044b},
01249 {0x10424, 0x1044c},
01250 {0x10425, 0x1044d},
01251 {0x10426, 0x1044e},
01252 {0x10427, 0x1044f},
01253 };
01254
01255 const CaseMapping upperMappings[] =
01256 {
01257 {0x61, 0x41},
01258 {0x62, 0x42},
01259 {0x63, 0x43},
01260 {0x64, 0x44},
01261 {0x65, 0x45},
01262 {0x66, 0x46},
01263 {0x67, 0x47},
01264 {0x68, 0x48},
01265 {0x69, 0x49},
01266 {0x6a, 0x4a},
01267 {0x6b, 0x4b},
01268 {0x6c, 0x4c},
01269 {0x6d, 0x4d},
01270 {0x6e, 0x4e},
01271 {0x6f, 0x4f},
01272 {0x70, 0x50},
01273 {0x71, 0x51},
01274 {0x72, 0x52},
01275 {0x73, 0x53},
01276 {0x74, 0x54},
01277 {0x75, 0x55},
01278 {0x76, 0x56},
01279 {0x77, 0x57},
01280 {0x78, 0x58},
01281 {0x79, 0x59},
01282 {0x7a, 0x5a},
01283 {0xb5, 0x39c},
01284 {0xe0, 0xc0},
01285 {0xe1, 0xc1},
01286 {0xe2, 0xc2},
01287 {0xe3, 0xc3},
01288 {0xe4, 0xc4},
01289 {0xe5, 0xc5},
01290 {0xe6, 0xc6},
01291 {0xe7, 0xc7},
01292 {0xe8, 0xc8},
01293 {0xe9, 0xc9},
01294 {0xea, 0xca},
01295 {0xeb, 0xcb},
01296 {0xec, 0xcc},
01297 {0xed, 0xcd},
01298 {0xee, 0xce},
01299 {0xef, 0xcf},
01300 {0xf0, 0xd0},
01301 {0xf1, 0xd1},
01302 {0xf2, 0xd2},
01303 {0xf3, 0xd3},
01304 {0xf4, 0xd4},
01305 {0xf5, 0xd5},
01306 {0xf6, 0xd6},
01307 {0xf8, 0xd8},
01308 {0xf9, 0xd9},
01309 {0xfa, 0xda},
01310 {0xfb, 0xdb},
01311 {0xfc, 0xdc},
01312 {0xfd, 0xdd},
01313 {0xfe, 0xde},
01314 {0xff, 0x178},
01315 {0x101, 0x100},
01316 {0x103, 0x102},
01317 {0x105, 0x104},
01318 {0x107, 0x106},
01319 {0x109, 0x108},
01320 {0x10b, 0x10a},
01321 {0x10d, 0x10c},
01322 {0x10f, 0x10e},
01323 {0x111, 0x110},
01324 {0x113, 0x112},
01325 {0x115, 0x114},
01326 {0x117, 0x116},
01327 {0x119, 0x118},
01328 {0x11b, 0x11a},
01329 {0x11d, 0x11c},
01330 {0x11f, 0x11e},
01331 {0x121, 0x120},
01332 {0x123, 0x122},
01333 {0x125, 0x124},
01334 {0x127, 0x126},
01335 {0x129, 0x128},
01336 {0x12b, 0x12a},
01337 {0x12d, 0x12c},
01338 {0x12f, 0x12e},
01339 {0x131, 0x49},
01340 {0x133, 0x132},
01341 {0x135, 0x134},
01342 {0x137, 0x136},
01343 {0x13a, 0x139},
01344 {0x13c, 0x13b},
01345 {0x13e, 0x13d},
01346 {0x140, 0x13f},
01347 {0x142, 0x141},
01348 {0x144, 0x143},
01349 {0x146, 0x145},
01350 {0x148, 0x147},
01351 {0x14b, 0x14a},
01352 {0x14d, 0x14c},
01353 {0x14f, 0x14e},
01354 {0x151, 0x150},
01355 {0x153, 0x152},
01356 {0x155, 0x154},
01357 {0x157, 0x156},
01358 {0x159, 0x158},
01359 {0x15b, 0x15a},
01360 {0x15d, 0x15c},
01361 {0x15f, 0x15e},
01362 {0x161, 0x160},
01363 {0x163, 0x162},
01364 {0x165, 0x164},
01365 {0x167, 0x166},
01366 {0x169, 0x168},
01367 {0x16b, 0x16a},
01368 {0x16d, 0x16c},
01369 {0x16f, 0x16e},
01370 {0x171, 0x170},
01371 {0x173, 0x172},
01372 {0x175, 0x174},
01373 {0x177, 0x176},
01374 {0x17a, 0x179},
01375 {0x17c, 0x17b},
01376 {0x17e, 0x17d},
01377 {0x17f, 0x53},
01378 {0x183, 0x182},
01379 {0x185, 0x184},
01380 {0x188, 0x187},
01381 {0x18c, 0x18b},
01382 {0x192, 0x191},
01383 {0x195, 0x1f6},
01384 {0x199, 0x198},
01385 {0x19e, 0x220},
01386 {0x1a1, 0x1a0},
01387 {0x1a3, 0x1a2},
01388 {0x1a5, 0x1a4},
01389 {0x1a8, 0x1a7},
01390 {0x1ad, 0x1ac},
01391 {0x1b0, 0x1af},
01392 {0x1b4, 0x1b3},
01393 {0x1b6, 0x1b5},
01394 {0x1b9, 0x1b8},
01395 {0x1bd, 0x1bc},
01396 {0x1bf, 0x1f7},
01397 {0x1c5, 0x1c4},
01398 {0x1c6, 0x1c4},
01399 {0x1c8, 0x1c7},
01400 {0x1c9, 0x1c7},
01401 {0x1cb, 0x1ca},
01402 {0x1cc, 0x1ca},
01403 {0x1ce, 0x1cd},
01404 {0x1d0, 0x1cf},
01405 {0x1d2, 0x1d1},
01406 {0x1d4, 0x1d3},
01407 {0x1d6, 0x1d5},
01408 {0x1d8, 0x1d7},
01409 {0x1da, 0x1d9},
01410 {0x1dc, 0x1db},
01411 {0x1dd, 0x18e},
01412 {0x1df, 0x1de},
01413 {0x1e1, 0x1e0},
01414 {0x1e3, 0x1e2},
01415 {0x1e5, 0x1e4},
01416 {0x1e7, 0x1e6},
01417 {0x1e9, 0x1e8},
01418 {0x1eb, 0x1ea},
01419 {0x1ed, 0x1ec},
01420 {0x1ef, 0x1ee},
01421 {0x1f2, 0x1f1},
01422 {0x1f3, 0x1f1},
01423 {0x1f5, 0x1f4},
01424 {0x1f9, 0x1f8},
01425 {0x1fb, 0x1fa},
01426 {0x1fd, 0x1fc},
01427 {0x1ff, 0x1fe},
01428 {0x201, 0x200},
01429 {0x203, 0x202},
01430 {0x205, 0x204},
01431 {0x207, 0x206},
01432 {0x209, 0x208},
01433 {0x20b, 0x20a},
01434 {0x20d, 0x20c},
01435 {0x20f, 0x20e},
01436 {0x211, 0x210},
01437 {0x213, 0x212},
01438 {0x215, 0x214},
01439 {0x217, 0x216},
01440 {0x219, 0x218},
01441 {0x21b, 0x21a},
01442 {0x21d, 0x21c},
01443 {0x21f, 0x21e},
01444 {0x223, 0x222},
01445 {0x225, 0x224},
01446 {0x227, 0x226},
01447 {0x229, 0x228},
01448 {0x22b, 0x22a},
01449 {0x22d, 0x22c},
01450 {0x22f, 0x22e},
01451 {0x231, 0x230},
01452 {0x233, 0x232},
01453 {0x253, 0x181},
01454 {0x254, 0x186},
01455 {0x256, 0x189},
01456 {0x257, 0x18a},
01457 {0x259, 0x18f},
01458 {0x25b, 0x190},
01459 {0x260, 0x193},
01460 {0x263, 0x194},
01461 {0x268, 0x197},
01462 {0x269, 0x196},
01463 {0x26f, 0x19c},
01464 {0x272, 0x19d},
01465 {0x275, 0x19f},
01466 {0x280, 0x1a6},
01467 {0x283, 0x1a9},
01468 {0x288, 0x1ae},
01469 {0x28a, 0x1b1},
01470 {0x28b, 0x1b2},
01471 {0x292, 0x1b7},
01472 {0x345, 0x399},
01473 {0x3ac, 0x386},
01474 {0x3ad, 0x388},
01475 {0x3ae, 0x389},
01476 {0x3af, 0x38a},
01477 {0x3b1, 0x391},
01478 {0x3b2, 0x392},
01479 {0x3b3, 0x393},
01480 {0x3b4, 0x394},
01481 {0x3b5, 0x395},
01482 {0x3b6, 0x396},
01483 {0x3b7, 0x397},
01484 {0x3b8, 0x398},
01485 {0x3b9, 0x399},
01486 {0x3ba, 0x39a},
01487 {0x3bb, 0x39b},
01488 {0x3bc, 0x39c},
01489 {0x3bd, 0x39d},
01490 {0x3be, 0x39e},
01491 {0x3bf, 0x39f},
01492 {0x3c0, 0x3a0},
01493 {0x3c1, 0x3a1},
01494 {0x3c2, 0x3a3},
01495 {0x3c3, 0x3a3},
01496 {0x3c4, 0x3a4},
01497 {0x3c5, 0x3a5},
01498 {0x3c6, 0x3a6},
01499 {0x3c7, 0x3a7},
01500 {0x3c8, 0x3a8},
01501 {0x3c9, 0x3a9},
01502 {0x3ca, 0x3aa},
01503 {0x3cb, 0x3ab},
01504 {0x3cc, 0x38c},
01505 {0x3cd, 0x38e},
01506 {0x3ce, 0x38f},
01507 {0x3d0, 0x392},
01508 {0x3d1, 0x398},
01509 {0x3d5, 0x3a6},
01510 {0x3d6, 0x3a0},
01511 {0x3d9, 0x3d8},
01512 {0x3db, 0x3da},
01513 {0x3dd, 0x3dc},
01514 {0x3df, 0x3de},
01515 {0x3e1, 0x3e0},
01516 {0x3e3, 0x3e2},
01517 {0x3e5, 0x3e4},
01518 {0x3e7, 0x3e6},
01519 {0x3e9, 0x3e8},
01520 {0x3eb, 0x3ea},
01521 {0x3ed, 0x3ec},
01522 {0x3ef, 0x3ee},
01523 {0x3f0, 0x39a},
01524 {0x3f1, 0x3a1},
01525 {0x3f2, 0x3f9},
01526 {0x3f5, 0x395},
01527 {0x3f8, 0x3f7},
01528 {0x3fb, 0x3fa},
01529 {0x430, 0x410},
01530 {0x431, 0x411},
01531 {0x432, 0x412},
01532 {0x433, 0x413},
01533 {0x434, 0x414},
01534 {0x435, 0x415},
01535 {0x436, 0x416},
01536 {0x437, 0x417},
01537 {0x438, 0x418},
01538 {0x439, 0x419},
01539 {0x43a, 0x41a},
01540 {0x43b, 0x41b},
01541 {0x43c, 0x41c},
01542 {0x43d, 0x41d},
01543 {0x43e, 0x41e},
01544 {0x43f, 0x41f},
01545 {0x440, 0x420},
01546 {0x441, 0x421},
01547 {0x442, 0x422},
01548 {0x443, 0x423},
01549 {0x444, 0x424},
01550 {0x445, 0x425},
01551 {0x446, 0x426},
01552 {0x447, 0x427},
01553 {0x448, 0x428},
01554 {0x449, 0x429},
01555 {0x44a, 0x42a},
01556 {0x44b, 0x42b},
01557 {0x44c, 0x42c},
01558 {0x44d, 0x42d},
01559 {0x44e, 0x42e},
01560 {0x44f, 0x42f},
01561 {0x450, 0x400},
01562 {0x451, 0x401},
01563 {0x452, 0x402},
01564 {0x453, 0x403},
01565 {0x454, 0x404},
01566 {0x455, 0x405},
01567 {0x456, 0x406},
01568 {0x457, 0x407},
01569 {0x458, 0x408},
01570 {0x459, 0x409},
01571 {0x45a, 0x40a},
01572 {0x45b, 0x40b},
01573 {0x45c, 0x40c},
01574 {0x45d, 0x40d},
01575 {0x45e, 0x40e},
01576 {0x45f, 0x40f},
01577 {0x461, 0x460},
01578 {0x463, 0x462},
01579 {0x465, 0x464},
01580 {0x467, 0x466},
01581 {0x469, 0x468},
01582 {0x46b, 0x46a},
01583 {0x46d, 0x46c},
01584 {0x46f, 0x46e},
01585 {0x471, 0x470},
01586 {0x473, 0x472},
01587 {0x475, 0x474},
01588 {0x477, 0x476},
01589 {0x479, 0x478},
01590 {0x47b, 0x47a},
01591 {0x47d, 0x47c},
01592 {0x47f, 0x47e},
01593 {0x481, 0x480},
01594 {0x48b, 0x48a},
01595 {0x48d, 0x48c},
01596 {0x48f, 0x48e},
01597 {0x491, 0x490},
01598 {0x493, 0x492},
01599 {0x495, 0x494},
01600 {0x497, 0x496},
01601 {0x499, 0x498},
01602 {0x49b, 0x49a},
01603 {0x49d, 0x49c},
01604 {0x49f, 0x49e},
01605 {0x4a1, 0x4a0},
01606 {0x4a3, 0x4a2},
01607 {0x4a5, 0x4a4},
01608 {0x4a7, 0x4a6},
01609 {0x4a9, 0x4a8},
01610 {0x4ab, 0x4aa},
01611 {0x4ad, 0x4ac},
01612 {0x4af, 0x4ae},
01613 {0x4b1, 0x4b0},
01614 {0x4b3, 0x4b2},
01615 {0x4b5, 0x4b4},
01616 {0x4b7, 0x4b6},
01617 {0x4b9, 0x4b8},
01618 {0x4bb, 0x4ba},
01619 {0x4bd, 0x4bc},
01620 {0x4bf, 0x4be},
01621 {0x4c2, 0x4c1},
01622 {0x4c4, 0x4c3},
01623 {0x4c6, 0x4c5},
01624 {0x4c8, 0x4c7},
01625 {0x4ca, 0x4c9},
01626 {0x4cc, 0x4cb},
01627 {0x4ce, 0x4cd},
01628 {0x4d1, 0x4d0},
01629 {0x4d3, 0x4d2},
01630 {0x4d5, 0x4d4},
01631 {0x4d7, 0x4d6},
01632 {0x4d9, 0x4d8},
01633 {0x4db, 0x4da},
01634 {0x4dd, 0x4dc},
01635 {0x4df, 0x4de},
01636 {0x4e1, 0x4e0},
01637 {0x4e3, 0x4e2},
01638 {0x4e5, 0x4e4},
01639 {0x4e7, 0x4e6},
01640 {0x4e9, 0x4e8},
01641 {0x4eb, 0x4ea},
01642 {0x4ed, 0x4ec},
01643 {0x4ef, 0x4ee},
01644 {0x4f1, 0x4f0},
01645 {0x4f3, 0x4f2},
01646 {0x4f5, 0x4f4},
01647 {0x4f9, 0x4f8},
01648 {0x501, 0x500},
01649 {0x503, 0x502},
01650 {0x505, 0x504},
01651 {0x507, 0x506},
01652 {0x509, 0x508},
01653 {0x50b, 0x50a},
01654 {0x50d, 0x50c},
01655 {0x50f, 0x50e},
01656 {0x561, 0x531},
01657 {0x562, 0x532},
01658 {0x563, 0x533},
01659 {0x564, 0x534},
01660 {0x565, 0x535},
01661 {0x566, 0x536},
01662 {0x567, 0x537},
01663 {0x568, 0x538},
01664 {0x569, 0x539},
01665 {0x56a, 0x53a},
01666 {0x56b, 0x53b},
01667 {0x56c, 0x53c},
01668 {0x56d, 0x53d},
01669 {0x56e, 0x53e},
01670 {0x56f, 0x53f},
01671 {0x570, 0x540},
01672 {0x571, 0x541},
01673 {0x572, 0x542},
01674 {0x573, 0x543},
01675 {0x574, 0x544},
01676 {0x575, 0x545},
01677 {0x576, 0x546},
01678 {0x577, 0x547},
01679 {0x578, 0x548},
01680 {0x579, 0x549},
01681 {0x57a, 0x54a},
01682 {0x57b, 0x54b},
01683 {0x57c, 0x54c},
01684 {0x57d, 0x54d},
01685 {0x57e, 0x54e},
01686 {0x57f, 0x54f},
01687 {0x580, 0x550},
01688 {0x581, 0x551},
01689 {0x582, 0x552},
01690 {0x583, 0x553},
01691 {0x584, 0x554},
01692 {0x585, 0x555},
01693 {0x586, 0x556},
01694 {0x1e01, 0x1e00},
01695 {0x1e03, 0x1e02},
01696 {0x1e05, 0x1e04},
01697 {0x1e07, 0x1e06},
01698 {0x1e09, 0x1e08},
01699 {0x1e0b, 0x1e0a},
01700 {0x1e0d, 0x1e0c},
01701 {0x1e0f, 0x1e0e},
01702 {0x1e11, 0x1e10},
01703 {0x1e13, 0x1e12},
01704 {0x1e15, 0x1e14},
01705 {0x1e17, 0x1e16},
01706 {0x1e19, 0x1e18},
01707 {0x1e1b, 0x1e1a},
01708 {0x1e1d, 0x1e1c},
01709 {0x1e1f, 0x1e1e},
01710 {0x1e21, 0x1e20},
01711 {0x1e23, 0x1e22},
01712 {0x1e25, 0x1e24},
01713 {0x1e27, 0x1e26},
01714 {0x1e29, 0x1e28},
01715 {0x1e2b, 0x1e2a},
01716 {0x1e2d, 0x1e2c},
01717 {0x1e2f, 0x1e2e},
01718 {0x1e31, 0x1e30},
01719 {0x1e33, 0x1e32},
01720 {0x1e35, 0x1e34},
01721 {0x1e37, 0x1e36},
01722 {0x1e39, 0x1e38},
01723 {0x1e3b, 0x1e3a},
01724 {0x1e3d, 0x1e3c},
01725 {0x1e3f, 0x1e3e},
01726 {0x1e41, 0x1e40},
01727 {0x1e43, 0x1e42},
01728 {0x1e45, 0x1e44},
01729 {0x1e47, 0x1e46},
01730 {0x1e49, 0x1e48},
01731 {0x1e4b, 0x1e4a},
01732 {0x1e4d, 0x1e4c},
01733 {0x1e4f, 0x1e4e},
01734 {0x1e51, 0x1e50},
01735 {0x1e53, 0x1e52},
01736 {0x1e55, 0x1e54},
01737 {0x1e57, 0x1e56},
01738 {0x1e59, 0x1e58},
01739 {0x1e5b, 0x1e5a},
01740 {0x1e5d, 0x1e5c},
01741 {0x1e5f, 0x1e5e},
01742 {0x1e61, 0x1e60},
01743 {0x1e63, 0x1e62},
01744 {0x1e65, 0x1e64},
01745 {0x1e67, 0x1e66},
01746 {0x1e69, 0x1e68},
01747 {0x1e6b, 0x1e6a},
01748 {0x1e6d, 0x1e6c},
01749 {0x1e6f, 0x1e6e},
01750 {0x1e71, 0x1e70},
01751 {0x1e73, 0x1e72},
01752 {0x1e75, 0x1e74},
01753 {0x1e77, 0x1e76},
01754 {0x1e79, 0x1e78},
01755 {0x1e7b, 0x1e7a},
01756 {0x1e7d, 0x1e7c},
01757 {0x1e7f, 0x1e7e},
01758 {0x1e81, 0x1e80},
01759 {0x1e83, 0x1e82},
01760 {0x1e85, 0x1e84},
01761 {0x1e87, 0x1e86},
01762 {0x1e89, 0x1e88},
01763 {0x1e8b, 0x1e8a},
01764 {0x1e8d, 0x1e8c},
01765 {0x1e8f, 0x1e8e},
01766 {0x1e91, 0x1e90},
01767 {0x1e93, 0x1e92},
01768 {0x1e95, 0x1e94},
01769 {0x1e9b, 0x1e60},
01770 {0x1ea1, 0x1ea0},
01771 {0x1ea3, 0x1ea2},
01772 {0x1ea5, 0x1ea4},
01773 {0x1ea7, 0x1ea6},
01774 {0x1ea9, 0x1ea8},
01775 {0x1eab, 0x1eaa},
01776 {0x1ead, 0x1eac},
01777 {0x1eaf, 0x1eae},
01778 {0x1eb1, 0x1eb0},
01779 {0x1eb3, 0x1eb2},
01780 {0x1eb5, 0x1eb4},
01781 {0x1eb7, 0x1eb6},
01782 {0x1eb9, 0x1eb8},
01783 {0x1ebb, 0x1eba},
01784 {0x1ebd, 0x1ebc},
01785 {0x1ebf, 0x1ebe},
01786 {0x1ec1, 0x1ec0},
01787 {0x1ec3, 0x1ec2},
01788 {0x1ec5, 0x1ec4},
01789 {0x1ec7, 0x1ec6},
01790 {0x1ec9, 0x1ec8},
01791 {0x1ecb, 0x1eca},
01792 {0x1ecd, 0x1ecc},
01793 {0x1ecf, 0x1ece},
01794 {0x1ed1, 0x1ed0},
01795 {0x1ed3, 0x1ed2},
01796 {0x1ed5, 0x1ed4},
01797 {0x1ed7, 0x1ed6},
01798 {0x1ed9, 0x1ed8},
01799 {0x1edb, 0x1eda},
01800 {0x1edd, 0x1edc},
01801 {0x1edf, 0x1ede},
01802 {0x1ee1, 0x1ee0},
01803 {0x1ee3, 0x1ee2},
01804 {0x1ee5, 0x1ee4},
01805 {0x1ee7, 0x1ee6},
01806 {0x1ee9, 0x1ee8},
01807 {0x1eeb, 0x1eea},
01808 {0x1eed, 0x1eec},
01809 {0x1eef, 0x1eee},
01810 {0x1ef1, 0x1ef0},
01811 {0x1ef3, 0x1ef2},
01812 {0x1ef5, 0x1ef4},
01813 {0x1ef7, 0x1ef6},
01814 {0x1ef9, 0x1ef8},
01815 {0x1f00, 0x1f08},
01816 {0x1f01, 0x1f09},
01817 {0x1f02, 0x1f0a},
01818 {0x1f03, 0x1f0b},
01819 {0x1f04, 0x1f0c},
01820 {0x1f05, 0x1f0d},
01821 {0x1f06, 0x1f0e},
01822 {0x1f07, 0x1f0f},
01823 {0x1f10, 0x1f18},
01824 {0x1f11, 0x1f19},
01825 {0x1f12, 0x1f1a},
01826 {0x1f13, 0x1f1b},
01827 {0x1f14, 0x1f1c},
01828 {0x1f15, 0x1f1d},
01829 {0x1f20, 0x1f28},
01830 {0x1f21, 0x1f29},
01831 {0x1f22, 0x1f2a},
01832 {0x1f23, 0x1f2b},
01833 {0x1f24, 0x1f2c},
01834 {0x1f25, 0x1f2d},
01835 {0x1f26, 0x1f2e},
01836 {0x1f27, 0x1f2f},
01837 {0x1f30, 0x1f38},
01838 {0x1f31, 0x1f39},
01839 {0x1f32, 0x1f3a},
01840 {0x1f33, 0x1f3b},
01841 {0x1f34, 0x1f3c},
01842 {0x1f35, 0x1f3d},
01843 {0x1f36, 0x1f3e},
01844 {0x1f37, 0x1f3f},
01845 {0x1f40, 0x1f48},
01846 {0x1f41, 0x1f49},
01847 {0x1f42, 0x1f4a},
01848 {0x1f43, 0x1f4b},
01849 {0x1f44, 0x1f4c},
01850 {0x1f45, 0x1f4d},
01851 {0x1f51, 0x1f59},
01852 {0x1f53, 0x1f5b},
01853 {0x1f55, 0x1f5d},
01854 {0x1f57, 0x1f5f},
01855 {0x1f60, 0x1f68},
01856 {0x1f61, 0x1f69},
01857 {0x1f62, 0x1f6a},
01858 {0x1f63, 0x1f6b},
01859 {0x1f64, 0x1f6c},
01860 {0x1f65, 0x1f6d},
01861 {0x1f66, 0x1f6e},
01862 {0x1f67, 0x1f6f},
01863 {0x1f70, 0x1fba},
01864 {0x1f71, 0x1fbb},
01865 {0x1f72, 0x1fc8},
01866 {0x1f73, 0x1fc9},
01867 {0x1f74, 0x1fca},
01868 {0x1f75, 0x1fcb},
01869 {0x1f76, 0x1fda},
01870 {0x1f77, 0x1fdb},
01871 {0x1f78, 0x1ff8},
01872 {0x1f79, 0x1ff9},
01873 {0x1f7a, 0x1fea},
01874 {0x1f7b, 0x1feb},
01875 {0x1f7c, 0x1ffa},
01876 {0x1f7d, 0x1ffb},
01877 {0x1f80, 0x1f88},
01878 {0x1f81, 0x1f89},
01879 {0x1f82, 0x1f8a},
01880 {0x1f83, 0x1f8b},
01881 {0x1f84, 0x1f8c},
01882 {0x1f85, 0x1f8d},
01883 {0x1f86, 0x1f8e},
01884 {0x1f87, 0x1f8f},
01885 {0x1f90, 0x1f98},
01886 {0x1f91, 0x1f99},
01887 {0x1f92, 0x1f9a},
01888 {0x1f93, 0x1f9b},
01889 {0x1f94, 0x1f9c},
01890 {0x1f95, 0x1f9d},
01891 {0x1f96, 0x1f9e},
01892 {0x1f97, 0x1f9f},
01893 {0x1fa0, 0x1fa8},
01894 {0x1fa1, 0x1fa9},
01895 {0x1fa2, 0x1faa},
01896 {0x1fa3, 0x1fab},
01897 {0x1fa4, 0x1fac},
01898 {0x1fa5, 0x1fad},
01899 {0x1fa6, 0x1fae},
01900 {0x1fa7, 0x1faf},
01901 {0x1fb0, 0x1fb8},
01902 {0x1fb1, 0x1fb9},
01903 {0x1fb3, 0x1fbc},
01904 {0x1fbe, 0x399},
01905 {0x1fc3, 0x1fcc},
01906 {0x1fd0, 0x1fd8},
01907 {0x1fd1, 0x1fd9},
01908 {0x1fe0, 0x1fe8},
01909 {0x1fe1, 0x1fe9},
01910 {0x1fe5, 0x1fec},
01911 {0x1ff3, 0x1ffc},
01912 {0x2170, 0x2160},
01913 {0x2171, 0x2161},
01914 {0x2172, 0x2162},
01915 {0x2173, 0x2163},
01916 {0x2174, 0x2164},
01917 {0x2175, 0x2165},
01918 {0x2176, 0x2166},
01919 {0x2177, 0x2167},
01920 {0x2178, 0x2168},
01921 {0x2179, 0x2169},
01922 {0x217a, 0x216a},
01923 {0x217b, 0x216b},
01924 {0x217c, 0x216c},
01925 {0x217d, 0x216d},
01926 {0x217e, 0x216e},
01927 {0x217f, 0x216f},
01928 {0x24d0, 0x24b6},
01929 {0x24d1, 0x24b7},
01930 {0x24d2, 0x24b8},
01931 {0x24d3, 0x24b9},
01932 {0x24d4, 0x24ba},
01933 {0x24d5, 0x24bb},
01934 {0x24d6, 0x24bc},
01935 {0x24d7, 0x24bd},
01936 {0x24d8, 0x24be},
01937 {0x24d9, 0x24bf},
01938 {0x24da, 0x24c0},
01939 {0x24db, 0x24c1},
01940 {0x24dc, 0x24c2},
01941 {0x24dd, 0x24c3},
01942 {0x24de, 0x24c4},
01943 {0x24df, 0x24c5},
01944 {0x24e0, 0x24c6},
01945 {0x24e1, 0x24c7},
01946 {0x24e2, 0x24c8},
01947 {0x24e3, 0x24c9},
01948 {0x24e4, 0x24ca},
01949 {0x24e5, 0x24cb},
01950 {0x24e6, 0x24cc},
01951 {0x24e7, 0x24cd},
01952 {0x24e8, 0x24ce},
01953 {0x24e9, 0x24cf},
01954 {0xff41, 0xff21},
01955 {0xff42, 0xff22},
01956 {0xff43, 0xff23},
01957 {0xff44, 0xff24},
01958 {0xff45, 0xff25},
01959 {0xff46, 0xff26},
01960 {0xff47, 0xff27},
01961 {0xff48, 0xff28},
01962 {0xff49, 0xff29},
01963 {0xff4a, 0xff2a},
01964 {0xff4b, 0xff2b},
01965 {0xff4c, 0xff2c},
01966 {0xff4d, 0xff2d},
01967 {0xff4e, 0xff2e},
01968 {0xff4f, 0xff2f},
01969 {0xff50, 0xff30},
01970 {0xff51, 0xff31},
01971 {0xff52, 0xff32},
01972 {0xff53, 0xff33},
01973 {0xff54, 0xff34},
01974 {0xff55, 0xff35},
01975 {0xff56, 0xff36},
01976 {0xff57, 0xff37},
01977 {0xff58, 0xff38},
01978 {0xff59, 0xff39},
01979 {0xff5a, 0xff3a},
01980 {0x10428, 0x10400},
01981 {0x10429, 0x10401},
01982 {0x1042a, 0x10402},
01983 {0x1042b, 0x10403},
01984 {0x1042c, 0x10404},
01985 {0x1042d, 0x10405},
01986 {0x1042e, 0x10406},
01987 {0x1042f, 0x10407},
01988 {0x10430, 0x10408},
01989 {0x10431, 0x10409},
01990 {0x10432, 0x1040a},
01991 {0x10433, 0x1040b},
01992 {0x10434, 0x1040c},
01993 {0x10435, 0x1040d},
01994 {0x10436, 0x1040e},
01995 {0x10437, 0x1040f},
01996 {0x10438, 0x10410},
01997 {0x10439, 0x10411},
01998 {0x1043a, 0x10412},
01999 {0x1043b, 0x10413},
02000 {0x1043c, 0x10414},
02001 {0x1043d, 0x10415},
02002 {0x1043e, 0x10416},
02003 {0x1043f, 0x10417},
02004 {0x10440, 0x10418},
02005 {0x10441, 0x10419},
02006 {0x10442, 0x1041a},
02007 {0x10443, 0x1041b},
02008 {0x10444, 0x1041c},
02009 {0x10445, 0x1041d},
02010 {0x10446, 0x1041e},
02011 {0x10447, 0x1041f},
02012 {0x10448, 0x10420},
02013 {0x10449, 0x10421},
02014 {0x1044a, 0x10422},
02015 {0x1044b, 0x10423},
02016 {0x1044c, 0x10424},
02017 {0x1044d, 0x10425},
02018 {0x1044e, 0x10426},
02019 {0x1044f, 0x10427},
02020 };
02021
02022 const CaseMapping* const lowerMappingsEnd = lowerMappings +
02023 (sizeof(lowerMappings)/sizeof(lowerMappings[0]));
02024
02025 const CaseMapping* const upperMappingsEnd = upperMappings +
02026 (sizeof(upperMappings)/sizeof(upperMappings[0]));
02027
02028 struct MappingOrdering
02029 {
02030 bool operator()(const CaseMapping& x, const CaseMapping& y)
02031 {
02032 return x.codePoint < y.codePoint;
02033 }
02034 };
02035
02036 struct Transformer
02037 {
02038 Transformer(const CaseMapping* const begin, const CaseMapping* const end)
02039 : m_begin(begin)
02040 , m_end(end)
02041 {
02042 }
02043
02044 UInt32 operator()(UInt32 in) const
02045 {
02046 CaseMapping val = { in, 0 };
02047 const CaseMapping* i = std::lower_bound(m_begin, m_end, val, MappingOrdering());
02048 if (i == m_end || i->codePoint != in)
02049 {
02050 return in;
02051 }
02052 else
02053 {
02054 return i->mapping;
02055 }
02056 }
02057 const CaseMapping* const m_begin;
02058 const CaseMapping* const m_end;
02059 };
02060
02061 }
02062
02064 bool toUpperCaseInPlace(char* input)
02065 {
02066 return transformInPlace(input, Transformer(upperMappings, upperMappingsEnd));
02067 }
02068
02070 String toUpperCase(const char* input)
02071 {
02072 return transform(input, Transformer(upperMappings, upperMappingsEnd));
02073 }
02074
02076 bool toLowerCaseInPlace(char* input)
02077 {
02078 return transformInPlace(input, Transformer(lowerMappings, lowerMappingsEnd));
02079 }
02080
02082 String toLowerCase(const char* input)
02083 {
02084 return transform(input, Transformer(lowerMappings, lowerMappingsEnd));
02085 }
02086
02087 }
02088
02089 }
02090
02091