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