c55dab446f
git-svn-id: https://svn.code.sf.net/p/flaim/code/trunk@7 0109f412-320b-0410-ab79-c3e0c5ffbbe6
2694 lines
74 KiB
C++
2694 lines
74 KiB
C++
//------------------------------------------------------------------------------
|
|
// Desc: This file contains the Unicode conversion routines
|
|
//
|
|
// Tabs: 3
|
|
//
|
|
// Copyright (c) 1999-2006 Novell, Inc. All Rights Reserved.
|
|
//
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of version 2 of the GNU General Public
|
|
// License as published by the Free Software Foundation.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, contact Novell, Inc.
|
|
//
|
|
// To contact Novell about this file by physical or electronic mail,
|
|
// you may find current contact information at www.novell.com
|
|
//
|
|
// $Id: funicode.cpp 3115 2006-01-19 13:24:39 -0700 (Thu, 19 Jan 2006) dsanders $
|
|
//------------------------------------------------------------------------------
|
|
|
|
#define DEF_FLM_UNI_GLOBALS
|
|
#include "flaimsys.h"
|
|
|
|
// Local constants
|
|
|
|
#define UTOWP60_ENTRIES 1502
|
|
|
|
// Mapping table
|
|
|
|
/****************************************************************************
|
|
Desc: UNICODE to WP6 character mapping table
|
|
Notes: This table is used to convert a subset of Unicode characters to
|
|
their WordPerfect equivalents so that the WP collation routines
|
|
can be used for indexing. This contains characters that can be
|
|
mapped 1:1 from Unicode->WP and from WP->Unicode. There is
|
|
no ambiguity and there are no character expansions or
|
|
contractions.
|
|
****************************************************************************/
|
|
FLMUINT16 WP_UTOWP60[ UTOWP60_ENTRIES][2] =
|
|
{
|
|
{ 0x00A1, 0x0407 }, // 7 , 4
|
|
{ 0x00A2, 0x0413 }, // 19 , 4
|
|
{ 0x00A3, 0x040b }, // 11 , 4
|
|
{ 0x00A4, 0x0418 }, // 24 , 4
|
|
{ 0x00A5, 0x040c }, // 12 , 4
|
|
{ 0x00A7, 0x0406 }, // 6 , 4
|
|
{ 0x00A9, 0x0417 }, // 23 , 4
|
|
{ 0x00AA, 0x040f }, // 15 , 4
|
|
{ 0x00AB, 0x0409 }, // 9 , 4
|
|
{ 0x00AC, 0x0614 }, // 20 , 6
|
|
{ 0x00AE, 0x0416 }, // 22 , 4
|
|
{ 0x00B0, 0x0624 }, // 36 , 6
|
|
{ 0x00B1, 0x0601 }, // 1 , 6
|
|
{ 0x00B2, 0x0414 }, // 20 , 4
|
|
{ 0x00B3, 0x041a }, // 26 , 4
|
|
{ 0x00B5, 0x0625 }, // 37 , 6
|
|
{ 0x00B6, 0x0405 }, // 5 , 4
|
|
{ 0x00B7, 0x0101 }, // 101, 1
|
|
{ 0x00B9, 0x044e }, // 78 , 4
|
|
{ 0x00BA, 0x0410 }, // 16 , 4
|
|
{ 0x00BB, 0x040a }, // 10 , 4
|
|
{ 0x00BC, 0x0412 }, // 18 , 4
|
|
{ 0x00BD, 0x0411 }, // 17 , 4
|
|
{ 0x00BE, 0x0419 }, // 25 , 4
|
|
{ 0x00BF, 0x0408 }, // 8 , 4
|
|
{ 0x00C0, 0x0120 }, // 32 , 1
|
|
{ 0x00C1, 0x011a }, // 26 , 1
|
|
{ 0x00C2, 0x011c }, // 28 , 1
|
|
{ 0x00C3, 0x014c }, // 76 , 1
|
|
{ 0x00C4, 0x011e }, // 30 , 1
|
|
{ 0x00C5, 0x0122 }, // 34 , 1
|
|
{ 0x00C6, 0x0124 }, // 36 , 1
|
|
{ 0x00C7, 0x0126 }, // 38 , 1
|
|
{ 0x00C8, 0x012e }, // 46 , 1
|
|
{ 0x00C9, 0x0128 }, // 40 , 1
|
|
{ 0x00CA, 0x012a }, // 42 , 1
|
|
{ 0x00CB, 0x012c }, // 44 , 1
|
|
{ 0x00CC, 0x0136 }, // 54 , 1
|
|
{ 0x00CD, 0x0130 }, // 48 , 1
|
|
{ 0x00CE, 0x0132 }, // 50 , 1
|
|
{ 0x00CF, 0x0134 }, // 52 , 1
|
|
{ 0x00D0, 0x0156 }, // 86 , 1
|
|
{ 0x00D1, 0x0138 }, // 56 , 1
|
|
{ 0x00D2, 0x0140 }, // 64 , 1
|
|
{ 0x00D3, 0x013a }, // 58 , 1
|
|
{ 0x00D4, 0x013c }, // 60 , 1
|
|
{ 0x00D5, 0x0152 }, // 82 , 1
|
|
{ 0x00D6, 0x013e }, // 62 , 1
|
|
{ 0x00D7, 0x0627 }, // 39 , 6
|
|
{ 0x00D8, 0x0150 }, // 80 , 1
|
|
{ 0x00D9, 0x0148 }, // 72 , 1
|
|
{ 0x00DA, 0x0142 }, // 66 , 1
|
|
{ 0x00DB, 0x0144 }, // 68 , 1
|
|
{ 0x00DC, 0x0146 }, // 70 , 1
|
|
{ 0x00DD, 0x0154 }, // 84 , 1
|
|
{ 0x00DE, 0x0158 }, // 88 , 1
|
|
{ 0x00DF, 0x0117 }, // 23 , 1
|
|
{ 0x00E0, 0x0121 }, // 33 , 1
|
|
{ 0x00E1, 0x011b }, // 27 , 1
|
|
{ 0x00E2, 0x011d }, // 29 , 1
|
|
{ 0x00E3, 0x014d }, // 77 , 1
|
|
{ 0x00E4, 0x011f }, // 31 , 1
|
|
{ 0x00E5, 0x0123 }, // 35 , 1
|
|
{ 0x00E6, 0x0125 }, // 37 , 1
|
|
{ 0x00E7, 0x0127 }, // 39 , 1
|
|
{ 0x00E8, 0x012f }, // 47 , 1
|
|
{ 0x00E9, 0x0129 }, // 41 , 1
|
|
{ 0x00EA, 0x012b }, // 43 , 1
|
|
{ 0x00EB, 0x012d }, // 45 , 1
|
|
{ 0x00EC, 0x0137 }, // 55 , 1
|
|
{ 0x00ED, 0x0131 }, // 49 , 1
|
|
{ 0x00EE, 0x0133 }, // 51 , 1
|
|
{ 0x00EF, 0x0135 }, // 53 , 1
|
|
{ 0x00F0, 0x0157 }, // 87 , 1
|
|
{ 0x00F1, 0x0139 }, // 57 , 1
|
|
{ 0x00F2, 0x0141 }, // 65 , 1
|
|
{ 0x00F3, 0x013b }, // 59 , 1
|
|
{ 0x00F4, 0x013d }, // 61 , 1
|
|
{ 0x00F5, 0x0153 }, // 83 , 1
|
|
{ 0x00F6, 0x013f }, // 63 , 1
|
|
{ 0x00F7, 0x0608 }, // 8 , 6
|
|
{ 0x00F8, 0x0151 }, // 81 , 1
|
|
{ 0x00F9, 0x0149 }, // 73 , 1
|
|
{ 0x00FA, 0x0143 }, // 67 , 1
|
|
{ 0x00FB, 0x0145 }, // 69 , 1
|
|
{ 0x00FC, 0x0147 }, // 71 , 1
|
|
{ 0x00FD, 0x0155 }, // 85 , 1
|
|
{ 0x00FE, 0x0159 }, // 89 , 1
|
|
{ 0x00FF, 0x014b }, // 75 , 1
|
|
{ 0x0100, 0x015c }, // 92 , 1
|
|
{ 0x0101, 0x015d }, // 93 , 1
|
|
{ 0x0102, 0x015a }, // 90 , 1
|
|
{ 0x0103, 0x015b }, // 91 , 1
|
|
{ 0x0104, 0x015e }, // 94 , 1
|
|
{ 0x0105, 0x015f }, // 95 , 1
|
|
{ 0x0106, 0x0160 }, // 96 , 1
|
|
{ 0x0107, 0x0161 }, // 97 , 1
|
|
{ 0x0108, 0x0164 }, // 100, 1
|
|
{ 0x0109, 0x0165 }, // 101, 1
|
|
{ 0x010A, 0x0166 }, // 102, 1
|
|
{ 0x010B, 0x0167 }, // 103, 1
|
|
{ 0x010C, 0x0162 }, // 98 , 1
|
|
{ 0x010D, 0x0163 }, // 99 , 1
|
|
{ 0x010E, 0x0168 }, // 104, 1
|
|
{ 0x010F, 0x0169 }, // 105, 1
|
|
{ 0x0110, 0x014e }, // 78 , 1
|
|
{ 0x0111, 0x014f }, // 79 , 1
|
|
{ 0x0112, 0x016e }, // 110, 1
|
|
{ 0x0113, 0x016f }, // 111, 1
|
|
{ 0x0114, 0x01ea }, // 234, 1
|
|
{ 0x0115, 0x01eb }, // 235, 1
|
|
{ 0x0116, 0x016c }, // 108, 1
|
|
{ 0x0117, 0x016d }, // 109, 1
|
|
{ 0x0118, 0x0170 }, // 112, 1
|
|
{ 0x0119, 0x0171 }, // 113, 1
|
|
{ 0x011A, 0x016a }, // 106, 1
|
|
{ 0x011B, 0x016b }, // 107, 1
|
|
{ 0x011C, 0x017a }, // 122, 1
|
|
{ 0x011D, 0x017b }, // 123, 1
|
|
{ 0x011E, 0x0174 }, // 116, 1
|
|
{ 0x011F, 0x0175 }, // 117, 1
|
|
{ 0x0120, 0x017c }, // 124, 1
|
|
{ 0x0121, 0x017d }, // 125, 1
|
|
{ 0x0122, 0x0178 }, // 120, 1
|
|
{ 0x0123, 0x0179 }, // 121, 1
|
|
{ 0x0124, 0x017e }, // 126, 1
|
|
{ 0x0125, 0x017f }, // 127, 1
|
|
{ 0x0126, 0x0180 }, // 128, 1
|
|
{ 0x0127, 0x0181 }, // 129, 1
|
|
{ 0x0128, 0x0188 }, // 136, 1
|
|
{ 0x0129, 0x0189 }, // 137, 1
|
|
{ 0x012A, 0x0184 }, // 132, 1
|
|
{ 0x012B, 0x0185 }, // 133, 1
|
|
{ 0x012C, 0x01ec }, // 236, 1
|
|
{ 0x012D, 0x01ed }, // 237, 1
|
|
{ 0x012E, 0x0186 }, // 134, 1
|
|
{ 0x012F, 0x0187 }, // 135, 1
|
|
{ 0x0130, 0x0182 }, // 130, 1
|
|
{ 0x0131, 0x01ef }, // 239, 1
|
|
{ 0x0132, 0x018a }, // 138, 1
|
|
{ 0x0133, 0x018b }, // 139, 1
|
|
{ 0x0134, 0x018c }, // 140, 1
|
|
{ 0x0135, 0x018d }, // 141, 1
|
|
{ 0x0136, 0x018e }, // 142, 1
|
|
{ 0x0137, 0x018f }, // 143, 1
|
|
{ 0x0138, 0x0118 }, // 24 , 1
|
|
{ 0x0139, 0x0190 }, // 144, 1
|
|
{ 0x013A, 0x0191 }, // 145, 1
|
|
{ 0x013B, 0x0194 }, // 148, 1
|
|
{ 0x013C, 0x0195 }, // 149, 1
|
|
{ 0x013D, 0x0192 }, // 146, 1
|
|
{ 0x013E, 0x0193 }, // 147, 1
|
|
{ 0x013F, 0x0196 }, // 150, 1
|
|
{ 0x0140, 0x0197 }, // 151, 1
|
|
{ 0x0141, 0x0198 }, // 152, 1
|
|
{ 0x0142, 0x0199 }, // 153, 1
|
|
{ 0x0143, 0x019a }, // 154, 1
|
|
{ 0x0144, 0x019b }, // 155, 1
|
|
{ 0x0145, 0x01a0 }, // 160, 1
|
|
{ 0x0146, 0x01a1 }, // 161, 1
|
|
{ 0x0147, 0x019e }, // 158, 1
|
|
{ 0x0148, 0x019f }, // 159, 1
|
|
{ 0x0149, 0x019d }, // 157, 1
|
|
{ 0x014A, 0x01d2 }, // 210, 1
|
|
{ 0x014B, 0x01d3 }, // 211, 1
|
|
{ 0x014C, 0x01a4 }, // 164, 1
|
|
{ 0x014D, 0x01a5 }, // 165, 1
|
|
{ 0x014E, 0x01f0 }, // 240, 1
|
|
{ 0x014F, 0x01f1 }, // 241, 1
|
|
{ 0x0150, 0x01a2 }, // 162, 1
|
|
{ 0x0151, 0x01a3 }, // 163, 1
|
|
{ 0x0152, 0x01a6 }, // 166, 1
|
|
{ 0x0153, 0x01a7 }, // 167, 1
|
|
{ 0x0154, 0x01a8 }, // 168, 1
|
|
{ 0x0155, 0x01a9 }, // 169, 1
|
|
{ 0x0156, 0x01ac }, // 172, 1
|
|
{ 0x0157, 0x01ad }, // 173, 1
|
|
{ 0x0158, 0x01aa }, // 170, 1
|
|
{ 0x0159, 0x01ab }, // 171, 1
|
|
{ 0x015A, 0x01ae }, // 174, 1
|
|
{ 0x015B, 0x01af }, // 175, 1
|
|
{ 0x015C, 0x01b4 }, // 180, 1
|
|
{ 0x015D, 0x01b5 }, // 181, 1
|
|
{ 0x015E, 0x01b2 }, // 178, 1
|
|
{ 0x015F, 0x01b3 }, // 179, 1
|
|
{ 0x0160, 0x01b0 }, // 176, 1
|
|
{ 0x0161, 0x01b1 }, // 177, 1
|
|
{ 0x0162, 0x01b8 }, // 184, 1
|
|
{ 0x0163, 0x01b9 }, // 185, 1
|
|
{ 0x0164, 0x01b6 }, // 182, 1
|
|
{ 0x0165, 0x01b7 }, // 183, 1
|
|
{ 0x0166, 0x01ba }, // 186, 1
|
|
{ 0x0167, 0x01bb }, // 187, 1
|
|
{ 0x0168, 0x01c6 }, // 198, 1
|
|
{ 0x0169, 0x01c7 }, // 199, 1
|
|
{ 0x016A, 0x01c0 }, // 192, 1
|
|
{ 0x016B, 0x01c1 }, // 193, 1
|
|
{ 0x016C, 0x01bc }, // 188, 1
|
|
{ 0x016D, 0x01bd }, // 189, 1
|
|
{ 0x016E, 0x01c4 }, // 196, 1
|
|
{ 0x016F, 0x01c5 }, // 197, 1
|
|
{ 0x0170, 0x01be }, // 190, 1
|
|
{ 0x0171, 0x01bf }, // 191, 1
|
|
{ 0x0172, 0x01c2 }, // 194, 1
|
|
{ 0x0173, 0x01c3 }, // 195, 1
|
|
{ 0x0174, 0x01c8 }, // 200, 1
|
|
{ 0x0175, 0x01c9 }, // 201, 1
|
|
{ 0x0176, 0x01ca }, // 202, 1
|
|
{ 0x0177, 0x01cb }, // 203, 1
|
|
{ 0x0178, 0x014a }, // 74 , 1
|
|
{ 0x0179, 0x01cc }, // 204, 1
|
|
{ 0x017A, 0x01cd }, // 205, 1
|
|
{ 0x017B, 0x01d0 }, // 208, 1
|
|
{ 0x017C, 0x01d1 }, // 209, 1
|
|
{ 0x017D, 0x01ce }, // 206, 1
|
|
{ 0x017E, 0x01cf }, // 207, 1
|
|
{ 0x0192, 0x040e }, // 14 , 4
|
|
{ 0x0194, 0x0a7c }, // 124, 10
|
|
{ 0x01A0, 0x01e6 }, // 230, 1
|
|
{ 0x01A1, 0x01e7 }, // 231, 1
|
|
{ 0x01AF, 0x01e8 }, // 232, 1
|
|
{ 0x01B0, 0x01e9 }, // 233, 1
|
|
{ 0x01C0, 0x0605 }, // 5 , 6
|
|
{ 0x0250, 0x0237 }, // 55 , 2
|
|
{ 0x0251, 0x0238 }, // 56 , 2
|
|
{ 0x0252, 0x0239 }, // 57 , 2
|
|
{ 0x0253, 0x023a }, // 58 , 2
|
|
{ 0x0254, 0x023c }, // 60 , 2
|
|
{ 0x0255, 0x023d }, // 61 , 2
|
|
{ 0x0256, 0x023f }, // 63 , 2
|
|
{ 0x0257, 0x0240 }, // 64 , 2
|
|
{ 0x0258, 0x0241 }, // 65 , 2
|
|
{ 0x0259, 0x0242 }, // 66 , 2
|
|
{ 0x025A, 0x0243 }, // 67 , 2
|
|
{ 0x025B, 0x0244 }, // 68 , 2
|
|
{ 0x025C, 0x0245 }, // 69 , 2
|
|
{ 0x025D, 0x0246 }, // 70 , 2
|
|
{ 0x025E, 0x0248 }, // 72 , 2
|
|
{ 0x025F, 0x0249 }, // 73 , 2
|
|
{ 0x0260, 0x024c }, // 76 , 2
|
|
{ 0x0261, 0x024b }, // 75 , 2
|
|
{ 0x0262, 0x024d }, // 77 , 2
|
|
{ 0x0263, 0x024f }, // 79 , 2
|
|
{ 0x0264, 0x0250 }, // 80 , 2
|
|
{ 0x0265, 0x0251 }, // 81 , 2
|
|
{ 0x0266, 0x0252 }, // 82 , 2
|
|
{ 0x0267, 0x0253 }, // 83 , 2
|
|
{ 0x0268, 0x0255 }, // 85 , 2
|
|
{ 0x0269, 0x0257 }, // 87 , 2
|
|
{ 0x026A, 0x0256 }, // 86 , 2
|
|
{ 0x026B, 0x025a }, // 90 , 2
|
|
{ 0x026C, 0x025b }, // 91 , 2
|
|
{ 0x026D, 0x025c }, // 92 , 2
|
|
{ 0x026E, 0x025e }, // 94 , 2
|
|
{ 0x026F, 0x0260 }, // 96 , 2
|
|
{ 0x0270, 0x0261 }, // 97 , 2
|
|
{ 0x0271, 0x0262 }, // 98 , 2
|
|
{ 0x0272, 0x0263 }, // 99 , 2
|
|
{ 0x0273, 0x0264 }, // 100, 2
|
|
{ 0x0274, 0x0265 }, // 101, 2
|
|
{ 0x0275, 0x0279 }, // 121, 2
|
|
{ 0x0276, 0x0266 }, // 102, 2
|
|
{ 0x0277, 0x0267 }, // 103, 2
|
|
{ 0x0278, 0x024a }, // 74 , 2
|
|
{ 0x0279, 0x0269 }, // 105, 2
|
|
{ 0x027A, 0x026a }, // 106, 2
|
|
{ 0x027B, 0x026b }, // 107, 2
|
|
{ 0x027C, 0x026c }, // 108, 2
|
|
{ 0x027D, 0x026d }, // 109, 2
|
|
{ 0x027E, 0x026e }, // 110, 2
|
|
{ 0x027F, 0x026f }, // 111, 2
|
|
{ 0x0280, 0x0270 }, // 112, 2
|
|
{ 0x0281, 0x0271 }, // 113, 2
|
|
{ 0x0282, 0x0272 }, // 114, 2
|
|
{ 0x0283, 0x0273 }, // 115, 2
|
|
{ 0x0284, 0x0274 }, // 116, 2
|
|
{ 0x0285, 0x0275 }, // 117, 2
|
|
{ 0x0286, 0x0276 }, // 118, 2
|
|
{ 0x0287, 0x0277 }, // 119, 2
|
|
{ 0x0288, 0x0278 }, // 120, 2
|
|
{ 0x0289, 0x027a }, // 122, 2
|
|
{ 0x028A, 0x027b }, // 123, 2
|
|
{ 0x028B, 0x027d }, // 125, 2
|
|
{ 0x028C, 0x027c }, // 124, 2
|
|
{ 0x028D, 0x027e }, // 126, 2
|
|
{ 0x028E, 0x025f }, // 95 , 2
|
|
{ 0x028F, 0x0280 }, // 128, 2
|
|
{ 0x0290, 0x0281 }, // 129, 2
|
|
{ 0x0291, 0x0282 }, // 130, 2
|
|
{ 0x0292, 0x0283 }, // 131, 2
|
|
{ 0x0293, 0x0284 }, // 132, 2
|
|
{ 0x0294, 0x0285 }, // 133, 2
|
|
{ 0x0295, 0x0286 }, // 134, 2
|
|
{ 0x0296, 0x0287 }, // 135, 2
|
|
{ 0x0297, 0x023e }, // 62 , 2
|
|
{ 0x0298, 0x028a }, // 138, 2
|
|
{ 0x0299, 0x023b }, // 59 , 2
|
|
{ 0x029A, 0x0247 }, // 71 , 2
|
|
{ 0x029B, 0x024e }, // 78 , 2
|
|
{ 0x029C, 0x0254 }, // 84 , 2
|
|
{ 0x029D, 0x0258 }, // 88 , 2
|
|
{ 0x029E, 0x0259 }, // 89 , 2
|
|
{ 0x029F, 0x025d }, // 93 , 2
|
|
{ 0x02A0, 0x0268 }, // 104, 2
|
|
{ 0x02A1, 0x0288 }, // 136, 2
|
|
{ 0x02A2, 0x0289 }, // 137, 2
|
|
{ 0x02A3, 0x028b }, // 139, 2
|
|
{ 0x02A4, 0x028c }, // 140, 2
|
|
{ 0x02A5, 0x028d }, // 141, 2
|
|
{ 0x02A6, 0x028e }, // 142, 2
|
|
{ 0x02A7, 0x028f }, // 143, 2
|
|
{ 0x02A8, 0x0290 }, // 144, 2
|
|
{ 0x02B0, 0x0235 }, // 53 , 2
|
|
{ 0x02B6, 0x0236 }, // 54 , 2
|
|
{ 0x02B9, 0x0200 }, // 0 , 2
|
|
{ 0x02BA, 0x0201 }, // 1 , 2
|
|
{ 0x02BB, 0x0202 }, // 2 , 2
|
|
{ 0x02BC, 0x0205 }, // 5 , 2
|
|
{ 0x02BD, 0x0204 }, // 4 , 2
|
|
{ 0x02BE, 0x0207 }, // 7 , 2
|
|
{ 0x02BF, 0x0208 }, // 8 , 2
|
|
{ 0x02C6, 0x0217 }, // 23 , 2
|
|
{ 0x02C7, 0x0218 }, // 24 , 2
|
|
{ 0x02C8, 0x020f }, // 15 , 2
|
|
{ 0x02C9, 0x0211 }, // 17 , 2
|
|
{ 0x02CA, 0x0212 }, // 18 , 2
|
|
{ 0x02CB, 0x0213 }, // 19 , 2
|
|
{ 0x02CC, 0x0210 }, // 16 , 2
|
|
{ 0x02CD, 0x0214 }, // 20 , 2
|
|
{ 0x02CE, 0x0215 }, // 21 , 2
|
|
{ 0x02CF, 0x0216 }, // 22 , 2
|
|
{ 0x02D0, 0x020a }, // 10 , 2
|
|
{ 0x02D1, 0x020b }, // 11 , 2
|
|
{ 0x02D2, 0x022a }, // 42 , 2
|
|
{ 0x02D3, 0x022b }, // 43 , 2
|
|
{ 0x02DA, 0x021b }, // 27 , 2
|
|
{ 0x02DB, 0x0231 }, // 49 , 2
|
|
{ 0x02DC, 0x0219 }, // 25 , 2
|
|
{ 0x02DE, 0x0233 }, // 51 , 2
|
|
{ 0x0300, 0x0100 }, // 0 , 1
|
|
{ 0x0301, 0x0106 }, // 6 , 1
|
|
{ 0x0302, 0x0103 }, // 3 , 1
|
|
{ 0x0303, 0x0102 }, // 2 , 1
|
|
{ 0x0304, 0x0108 }, // 8 , 1
|
|
{ 0x0305, 0x0115 }, // 21 , 1
|
|
{ 0x0306, 0x0116 }, // 22 , 1
|
|
{ 0x0307, 0x010f }, // 15 , 1
|
|
{ 0x0308, 0x0107 }, // 7 , 1
|
|
{ 0x030A, 0x010e }, // 14 , 1
|
|
{ 0x030B, 0x0110 }, // 16 , 1
|
|
{ 0x030C, 0x0113 }, // 19 , 1
|
|
{ 0x0310, 0x0209 }, // 9 , 2
|
|
{ 0x0311, 0x0858 }, // 88 , 8
|
|
{ 0x0313, 0x0109 }, // 9 , 1
|
|
{ 0x0314, 0x085a }, // 90 , 8
|
|
{ 0x0315, 0x010a }, // 10 , 1
|
|
{ 0x031C, 0x0221 }, // 33 , 2
|
|
{ 0x031D, 0x0222 }, // 34 , 2
|
|
{ 0x031E, 0x0223 }, // 35 , 2
|
|
{ 0x031F, 0x0224 }, // 36 , 2
|
|
{ 0x0320, 0x0225 }, // 37 , 2
|
|
{ 0x0321, 0x0226 }, // 38 , 2
|
|
{ 0x0322, 0x0227 }, // 39 , 2
|
|
{ 0x0323, 0x021e }, // 30 , 2
|
|
{ 0x0324, 0x0220 }, // 32 , 2
|
|
{ 0x0325, 0x021a }, // 26 , 2
|
|
{ 0x0326, 0x010c }, // 12 , 1
|
|
{ 0x0327, 0x0111 }, // 17 , 1
|
|
{ 0x0328, 0x0112 }, // 18 , 1
|
|
{ 0x0329, 0x020e }, // 14 , 2
|
|
{ 0x032A, 0x0228 }, // 40 , 2
|
|
{ 0x032B, 0x0229 }, // 41 , 2
|
|
{ 0x032C, 0x021d }, // 29 , 2
|
|
{ 0x032D, 0x021c }, // 28 , 2
|
|
{ 0x032E, 0x020d }, // 13 , 2
|
|
{ 0x0335, 0x0104 }, // 4 , 1
|
|
{ 0x0337, 0x0114 }, // 20 , 1
|
|
{ 0x0338, 0x0105 }, // 5 , 1
|
|
{ 0x033E, 0x0230 }, // 48 , 2
|
|
{ 0x0345, 0x085b }, // 91 , 8
|
|
{ 0x0374, 0x0851 }, // 81 , 8
|
|
{ 0x0375, 0x0852 }, // 82 , 8
|
|
{ 0x0391, 0x0800 }, // 0 , 8
|
|
{ 0x0392, 0x0802 }, // 2 , 8
|
|
{ 0x0393, 0x0806 }, // 6 , 8
|
|
{ 0x0394, 0x0808 }, // 8 , 8
|
|
{ 0x0395, 0x080a }, // 10 , 8
|
|
{ 0x0396, 0x080c }, // 12 , 8
|
|
{ 0x0397, 0x080e }, // 14 , 8
|
|
{ 0x0398, 0x0810 }, // 16 , 8
|
|
{ 0x0399, 0x0812 }, // 18 , 8
|
|
{ 0x039A, 0x0814 }, // 20 , 8
|
|
{ 0x039B, 0x0816 }, // 22 , 8
|
|
{ 0x039C, 0x0818 }, // 24 , 8
|
|
{ 0x039D, 0x081a }, // 26 , 8
|
|
{ 0x039E, 0x081c }, // 28 , 8
|
|
{ 0x039F, 0x081e }, // 30 , 8
|
|
{ 0x03A0, 0x0820 }, // 32 , 8
|
|
{ 0x03A1, 0x0822 }, // 34 , 8
|
|
{ 0x03A3, 0x0824 }, // 36 , 8
|
|
{ 0x03A4, 0x0828 }, // 40 , 8
|
|
{ 0x03A5, 0x082a }, // 42 , 8
|
|
{ 0x03A6, 0x082c }, // 44 , 8
|
|
{ 0x03A7, 0x082e }, // 46 , 8
|
|
{ 0x03A8, 0x0830 }, // 48 , 8
|
|
{ 0x03A9, 0x0832 }, // 50 , 8
|
|
{ 0x03AA, 0x083c }, // 60 , 8
|
|
{ 0x03AB, 0x0842 }, // 66 , 8
|
|
{ 0x03AC, 0x0835 }, // 53 , 8
|
|
{ 0x03AD, 0x0837 }, // 55 , 8
|
|
{ 0x03AE, 0x0839 }, // 57 , 8
|
|
{ 0x03AF, 0x083b }, // 59 , 8
|
|
{ 0x03B1, 0x0801 }, // 1 , 8
|
|
{ 0x03B2, 0x0803 }, // 3 , 8
|
|
{ 0x03B3, 0x0807 }, // 7 , 8
|
|
{ 0x03B4, 0x0809 }, // 9 , 8
|
|
{ 0x03B5, 0x080b }, // 11 , 8
|
|
{ 0x03B6, 0x080d }, // 13 , 8
|
|
{ 0x03B7, 0x080f }, // 15 , 8
|
|
{ 0x03B8, 0x0811 }, // 17 , 8
|
|
{ 0x03B9, 0x0813 }, // 19 , 8
|
|
{ 0x03BA, 0x0815 }, // 21 , 8
|
|
{ 0x03BB, 0x0817 }, // 23 , 8
|
|
{ 0x03BC, 0x0819 }, // 25 , 8
|
|
{ 0x03BD, 0x081b }, // 27 , 8
|
|
{ 0x03BE, 0x081d }, // 29 , 8
|
|
{ 0x03BF, 0x081f }, // 31 , 8
|
|
{ 0x03C0, 0x0821 }, // 33 , 8
|
|
{ 0x03C1, 0x0823 }, // 35 , 8
|
|
{ 0x03C2, 0x0827 }, // 39 , 8
|
|
{ 0x03C3, 0x0825 }, // 37 , 8
|
|
{ 0x03C4, 0x0829 }, // 41 , 8
|
|
{ 0x03C5, 0x082b }, // 43 , 8
|
|
{ 0x03C6, 0x082d }, // 45 , 8
|
|
{ 0x03C7, 0x082f }, // 47 , 8
|
|
{ 0x03C8, 0x0831 }, // 49 , 8
|
|
{ 0x03C9, 0x0833 }, // 51 , 8
|
|
{ 0x03CA, 0x083d }, // 61 , 8
|
|
{ 0x03CB, 0x0843 }, // 67 , 8
|
|
{ 0x03CC, 0x083f }, // 63 , 8
|
|
{ 0x03CD, 0x0841 }, // 65 , 8
|
|
{ 0x03CE, 0x0845 }, // 69 , 8
|
|
{ 0x03D0, 0x0805 }, // 5 , 8
|
|
{ 0x03D1, 0x0847 }, // 71 , 8
|
|
{ 0x03D2, 0x084c }, // 76 , 8
|
|
{ 0x03D5, 0x084d }, // 77 , 8
|
|
{ 0x03D6, 0x0849 }, // 73 , 8
|
|
{ 0x03D7, 0x084f }, // 79 , 8
|
|
{ 0x03DA, 0x08d7 }, // 215, 8
|
|
{ 0x03DB, 0x084B }, // 75 , 8
|
|
{ 0x03DC, 0x08d8 }, // 216, 8
|
|
{ 0x03DE, 0x08d9 }, // 217, 8
|
|
{ 0x03E0, 0x08da }, // 218, 8
|
|
{ 0x03F0, 0x0848 }, // 72 , 8
|
|
{ 0x03F1, 0x084a }, // 74 , 8
|
|
{ 0x0401, 0x0a0c }, // 12 , 10
|
|
{ 0x0402, 0x0a4a }, // 74 , 10
|
|
{ 0x0403, 0x0a44 }, // 68 , 10
|
|
{ 0x0404, 0x0a4e }, // 78 , 10
|
|
{ 0x0405, 0x0a52 }, // 82 , 10
|
|
{ 0x0406, 0x0a58 }, // 88 , 10
|
|
{ 0x0407, 0x0a5a }, // 90 , 10
|
|
{ 0x0408, 0x0a5e }, // 94 , 10
|
|
{ 0x0409, 0x0a68 }, // 104, 10
|
|
{ 0x040A, 0x0a6c }, // 108, 10
|
|
{ 0x040B, 0x0a72 }, // 114, 10
|
|
{ 0x040C, 0x0a60 }, // 96 , 10
|
|
{ 0x040E, 0x0a74 }, // 116, 10
|
|
{ 0x040F, 0x0a86 }, // 134, 10
|
|
{ 0x0410, 0x0a00 }, // 0 , 10
|
|
{ 0x0411, 0x0a02 }, // 2 , 10
|
|
{ 0x0412, 0x0a04 }, // 4 , 10
|
|
{ 0x0413, 0x0a06 }, // 6 , 10
|
|
{ 0x0414, 0x0a08 }, // 8 , 10
|
|
{ 0x0415, 0x0a0a }, // 10 , 10
|
|
{ 0x0416, 0x0a0e }, // 14 , 10
|
|
{ 0x0417, 0x0a10 }, // 16 , 10
|
|
{ 0x0418, 0x0a12 }, // 18 , 10
|
|
{ 0x0419, 0x0a14 }, // 20 , 10
|
|
{ 0x041A, 0x0a16 }, // 22 , 10
|
|
{ 0x041B, 0x0a18 }, // 24 , 10
|
|
{ 0x041C, 0x0a1a }, // 26 , 10
|
|
{ 0x041D, 0x0a1c }, // 28 , 10
|
|
{ 0x041E, 0x0a1e }, // 30 , 10
|
|
{ 0x041F, 0x0a20 }, // 32 , 10
|
|
{ 0x0420, 0x0a22 }, // 34 , 10
|
|
{ 0x0421, 0x0a24 }, // 36 , 10
|
|
{ 0x0422, 0x0a26 }, // 38 , 10
|
|
{ 0x0423, 0x0a28 }, // 40 , 10
|
|
{ 0x0424, 0x0a2a }, // 42 , 10
|
|
{ 0x0425, 0x0a2c }, // 44 , 10
|
|
{ 0x0426, 0x0a2e }, // 46 , 10
|
|
{ 0x0427, 0x0a30 }, // 48 , 10
|
|
{ 0x0428, 0x0a32 }, // 50 , 10
|
|
{ 0x0429, 0x0a34 }, // 52 , 10
|
|
{ 0x042A, 0x0a36 }, // 54 , 10
|
|
{ 0x042B, 0x0a38 }, // 56 , 10
|
|
{ 0x042C, 0x0a3a }, // 58 , 10
|
|
{ 0x042D, 0x0a3c }, // 60 , 10
|
|
{ 0x042E, 0x0a3e }, // 62 , 10
|
|
{ 0x042F, 0x0a40 }, // 64 , 10
|
|
{ 0x0430, 0x0a01 }, // 1 , 10
|
|
{ 0x0431, 0x0a03 }, // 3 , 10
|
|
{ 0x0432, 0x0a05 }, // 5 , 10
|
|
{ 0x0433, 0x0a07 }, // 7 , 10
|
|
{ 0x0434, 0x0a09 }, // 9 , 10
|
|
{ 0x0435, 0x0a0b }, // 11 , 10
|
|
{ 0x0436, 0x0a0f }, // 15 , 10
|
|
{ 0x0437, 0x0a11 }, // 17 , 10
|
|
{ 0x0438, 0x0a13 }, // 19 , 10
|
|
{ 0x0439, 0x0a15 }, // 21 , 10
|
|
{ 0x043A, 0x0a17 }, // 23 , 10
|
|
{ 0x043B, 0x0a19 }, // 25 , 10
|
|
{ 0x043C, 0x0a1b }, // 27 , 10
|
|
{ 0x043D, 0x0a1d }, // 29 , 10
|
|
{ 0x043E, 0x0a1f }, // 31 , 10
|
|
{ 0x043F, 0x0a21 }, // 33 , 10
|
|
{ 0x0440, 0x0a23 }, // 35 , 10
|
|
{ 0x0441, 0x0a25 }, // 37 , 10
|
|
{ 0x0442, 0x0a27 }, // 39 , 10
|
|
{ 0x0443, 0x0a29 }, // 41 , 10
|
|
{ 0x0444, 0x0a2b }, // 43 , 10
|
|
{ 0x0445, 0x0a2d }, // 45 , 10
|
|
{ 0x0446, 0x0a2f }, // 47 , 10
|
|
{ 0x0447, 0x0a31 }, // 49 , 10
|
|
{ 0x0448, 0x0a33 }, // 51 , 10
|
|
{ 0x0449, 0x0a35 }, // 53 , 10
|
|
{ 0x044A, 0x0a37 }, // 55 , 10
|
|
{ 0x044B, 0x0a39 }, // 57 , 10
|
|
{ 0x044C, 0x0a3b }, // 59 , 10
|
|
{ 0x044D, 0x0a3d }, // 61 , 10
|
|
{ 0x044E, 0x0a3f }, // 63 , 10
|
|
{ 0x044F, 0x0a41 }, // 65 , 10
|
|
{ 0x0451, 0x0a0d }, // 13 , 10
|
|
{ 0x0452, 0x0a4b }, // 75 , 10
|
|
{ 0x0453, 0x0a45 }, // 69 , 10
|
|
{ 0x0454, 0x0a4f }, // 79 , 10
|
|
{ 0x0455, 0x0a53 }, // 83 , 10
|
|
{ 0x0456, 0x0a59 }, // 89 , 10
|
|
{ 0x0457, 0x0a5b }, // 91 , 10
|
|
{ 0x0458, 0x0a5f }, // 95 , 10
|
|
{ 0x0459, 0x0a69 }, // 105, 10
|
|
{ 0x045A, 0x0a6d }, // 109, 10
|
|
{ 0x045B, 0x0a73 }, // 115, 10
|
|
{ 0x045C, 0x0a61 }, // 97 , 10
|
|
{ 0x045E, 0x0a75 }, // 117, 10
|
|
{ 0x045F, 0x0a87 }, // 135, 10
|
|
{ 0x0460, 0x0a70 }, // 112, 10
|
|
{ 0x0461, 0x0a71 }, // 113, 10
|
|
{ 0x0462, 0x0a8e }, // 142, 10
|
|
{ 0x0463, 0x0a8f }, // 143, 10
|
|
{ 0x0466, 0x0a90 }, // 144, 10
|
|
{ 0x0467, 0x0a91 }, // 145, 10
|
|
{ 0x046A, 0x0a92 }, // 146, 10
|
|
{ 0x046B, 0x0a93 }, // 147, 10
|
|
{ 0x046E, 0x0a94 }, // 148, 10
|
|
{ 0x046F, 0x0a95 }, // 149, 10
|
|
{ 0x0470, 0x0a96 }, // 150, 10
|
|
{ 0x0471, 0x0a97 }, // 151, 10
|
|
{ 0x0472, 0x0a98 }, // 152, 10
|
|
{ 0x0473, 0x0a99 }, // 153, 10
|
|
{ 0x0474, 0x0a9a }, // 154, 10
|
|
{ 0x0475, 0x0a9b }, // 155, 10
|
|
{ 0x047A, 0x0a6e }, // 110, 10
|
|
{ 0x047B, 0x0a6f }, // 111, 10
|
|
{ 0x047E, 0x0a84 }, // 132, 10
|
|
{ 0x047F, 0x0a85 }, // 133, 10
|
|
{ 0x0490, 0x0a46 }, // 70 , 10
|
|
{ 0x0491, 0x0a47 }, // 71 , 10
|
|
{ 0x0492, 0x0a48 }, // 72 , 10
|
|
{ 0x0493, 0x0a49 }, // 73 , 10
|
|
{ 0x0496, 0x0a50 }, // 80 , 10
|
|
{ 0x0497, 0x0a51 }, // 81 , 10
|
|
{ 0x049A, 0x0a62 }, // 98 , 10
|
|
{ 0x049B, 0x0a63 }, // 99 , 10
|
|
{ 0x049C, 0x0a66 }, // 102, 10
|
|
{ 0x049D, 0x0a67 }, // 103, 10
|
|
{ 0x04A2, 0x0a6a }, // 106, 10
|
|
{ 0x04A3, 0x0a6b }, // 107, 10
|
|
{ 0x04AE, 0x0a78 }, // 120, 10
|
|
{ 0x04AF, 0x0a79 }, // 121, 10
|
|
{ 0x04B0, 0x0a7a }, // 122, 10
|
|
{ 0x04B1, 0x0a7b }, // 123, 10
|
|
{ 0x04B2, 0x0a7e }, // 126, 10
|
|
{ 0x04B3, 0x0a7f }, // 127, 10
|
|
{ 0x04B6, 0x0a88 }, // 136, 10
|
|
{ 0x04B7, 0x0a89 }, // 137, 10
|
|
{ 0x04B8, 0x0a8a }, // 138, 10
|
|
{ 0x04B9, 0x0a8b }, // 139, 10
|
|
{ 0x04BA, 0x0a82 }, // 130, 10
|
|
{ 0x04BB, 0x0a83 }, // 131, 10
|
|
{ 0x04D8, 0x0a42 }, // 66 , 10
|
|
{ 0x04D9, 0x0a43 }, // 67 , 10
|
|
{ 0x04EE, 0x0a76 }, // 118, 10
|
|
{ 0x04EF, 0x0a77 }, // 119, 10
|
|
{ 0x05B0, 0x0920 }, // 32 , 9
|
|
{ 0x05B1, 0x0921 }, // 33 , 9
|
|
{ 0x05B2, 0x0922 }, // 34 , 9
|
|
{ 0x05B3, 0x0923 }, // 35 , 9
|
|
{ 0x05B4, 0x0924 }, // 36 , 9
|
|
{ 0x05B5, 0x0925 }, // 37 , 9
|
|
{ 0x05B6, 0x0926 }, // 38 , 9
|
|
{ 0x05B7, 0x0927 }, // 39 , 9
|
|
{ 0x05B8, 0x0928 }, // 40 , 9
|
|
{ 0x05B9, 0x0929 }, // 41 , 9
|
|
{ 0x05BB, 0x092b }, // 43 , 9
|
|
{ 0x05BC, 0x092c }, // 44 , 9
|
|
{ 0x05BD, 0x092d }, // 45 , 9
|
|
{ 0x05BF, 0x092e }, // 46 , 9
|
|
{ 0x05C0, 0x091c }, // 28 , 9
|
|
{ 0x05C3, 0x091d }, // 29 , 9
|
|
{ 0x05D0, 0x0900 }, // 0 , 9
|
|
{ 0x05D1, 0x0901 }, // 1 , 9
|
|
{ 0x05D2, 0x0902 }, // 2 , 9
|
|
{ 0x05D3, 0x0903 }, // 3 , 9
|
|
{ 0x05D4, 0x0904 }, // 4 , 9
|
|
{ 0x05D5, 0x0905 }, // 5 , 9
|
|
{ 0x05D6, 0x0906 }, // 6 , 9
|
|
{ 0x05D7, 0x0907 }, // 7 , 9
|
|
{ 0x05D8, 0x0908 }, // 8 , 9
|
|
{ 0x05D9, 0x0909 }, // 9 , 9
|
|
{ 0x05DA, 0x090a }, // 10 , 9
|
|
{ 0x05DB, 0x090b }, // 11 , 9
|
|
{ 0x05DC, 0x090c }, // 12 , 9
|
|
{ 0x05DD, 0x090d }, // 13 , 9
|
|
{ 0x05DE, 0x090e }, // 14 , 9
|
|
{ 0x05DF, 0x090f }, // 15 , 9
|
|
{ 0x05E0, 0x0910 }, // 16 , 9
|
|
{ 0x05E1, 0x0911 }, // 17 , 9
|
|
{ 0x05E2, 0x0912 }, // 18 , 9
|
|
{ 0x05E3, 0x0913 }, // 19 , 9
|
|
{ 0x05E4, 0x0914 }, // 20 , 9
|
|
{ 0x05E5, 0x0915 }, // 21 , 9
|
|
{ 0x05E6, 0x0916 }, // 22 , 9
|
|
{ 0x05E7, 0x0917 }, // 23 , 9
|
|
{ 0x05E8, 0x0918 }, // 24 , 9
|
|
{ 0x05E9, 0x0919 }, // 25 , 9
|
|
{ 0x05EA, 0x091a }, // 26 , 9
|
|
{ 0x05F0, 0x0931 }, // 49 , 9
|
|
{ 0x05F1, 0x0932 }, // 50 , 9
|
|
{ 0x05F2, 0x0933 }, // 51 , 9
|
|
{ 0x05F3, 0x091e }, // 30 , 9
|
|
{ 0x05F4, 0x091f }, // 31 , 9
|
|
{ 0x060C, 0x0d26 }, // 38 , 13
|
|
{ 0x061B, 0x0d27 }, // 39 , 13
|
|
{ 0x061F, 0x0d28 }, // 40 , 13
|
|
{ 0x0621, 0x0da4 }, // 164, 13
|
|
{ 0x0622, 0x0db1 }, // 177, 13
|
|
{ 0x0623, 0x0da5 }, // 165, 13
|
|
{ 0x0624, 0x0da9 }, // 169, 13
|
|
{ 0x0625, 0x0da7 }, // 167, 13
|
|
{ 0x0626, 0x0dab }, // 171, 13
|
|
{ 0x0627, 0x0d3a }, // 58 , 13
|
|
{ 0x0628, 0x0d3c }, // 60 , 13
|
|
{ 0x0629, 0x0d98 }, // 152, 13
|
|
{ 0x062A, 0x0d40 }, // 64 , 13
|
|
{ 0x062B, 0x0d44 }, // 68 , 13
|
|
{ 0x062C, 0x0d48 }, // 72 , 13
|
|
{ 0x062D, 0x0d4c }, // 76 , 13
|
|
{ 0x062E, 0x0d50 }, // 80 , 13
|
|
{ 0x062F, 0x0d54 }, // 84 , 13
|
|
{ 0x0630, 0x0d56 }, // 86 , 13
|
|
{ 0x0631, 0x0d58 }, // 88 , 13
|
|
{ 0x0632, 0x0d5a }, // 90 , 13
|
|
{ 0x0633, 0x0d5c }, // 92 , 13
|
|
{ 0x0634, 0x0d60 }, // 96 , 13
|
|
{ 0x0635, 0x0d64 }, // 100, 13
|
|
{ 0x0636, 0x0d68 }, // 104, 13
|
|
{ 0x0637, 0x0d6c }, // 108, 13
|
|
{ 0x0638, 0x0d70 }, // 112, 13
|
|
{ 0x0639, 0x0d74 }, // 116, 13
|
|
{ 0x063A, 0x0d78 }, // 120, 13
|
|
{ 0x0640, 0x0dc2 }, // 194, 13
|
|
{ 0x0641, 0x0d7c }, // 124, 13
|
|
{ 0x0642, 0x0d80 }, // 128, 13
|
|
{ 0x0643, 0x0d84 }, // 132, 13
|
|
{ 0x0644, 0x0d88 }, // 136, 13
|
|
{ 0x0645, 0x0d8c }, // 140, 13
|
|
{ 0x0646, 0x0d90 }, // 144, 13
|
|
{ 0x0647, 0x0d94 }, // 148, 13
|
|
{ 0x0648, 0x0d9a }, // 154, 13
|
|
{ 0x0649, 0x0da0 }, // 160, 13
|
|
{ 0x064A, 0x0d9c }, // 156, 13
|
|
{ 0x064B, 0x0d10 }, // 16 , 13
|
|
{ 0x064C, 0x0d11 }, // 17 , 13
|
|
{ 0x064E, 0x0d0a }, // 10 , 13
|
|
{ 0x064F, 0x0d0c }, // 12 , 13
|
|
{ 0x0650, 0x0d0e }, // 14 , 13
|
|
{ 0x0651, 0x0d16 }, // 22 , 13
|
|
{ 0x0652, 0x0d14 }, // 20 , 13
|
|
{ 0x0660, 0x0d38 }, // 56 , 13
|
|
{ 0x0661, 0x0d2f }, // 47 , 13
|
|
{ 0x0662, 0x0d30 }, // 48 , 13
|
|
{ 0x0663, 0x0d31 }, // 49 , 13
|
|
{ 0x0664, 0x0d32 }, // 50 , 13
|
|
{ 0x0665, 0x0d33 }, // 51 , 13
|
|
{ 0x0666, 0x0d34 }, // 52 , 13
|
|
{ 0x0667, 0x0d35 }, // 53 , 13
|
|
{ 0x0668, 0x0d36 }, // 54 , 13
|
|
{ 0x0669, 0x0d37 }, // 55 , 13
|
|
{ 0x066A, 0x0d2a }, // 42 , 13
|
|
{ 0x0671, 0x0db3 }, // 179, 13
|
|
{ 0x0674, 0x0d24 }, // 36 , 13
|
|
{ 0x0679, 0x0e3c }, // 60 , 14
|
|
{ 0x067A, 0x0e4c }, // 76 , 14
|
|
{ 0x067B, 0x0e30 }, // 48 , 14
|
|
{ 0x067C, 0x0e40 }, // 64 , 14
|
|
{ 0x067D, 0x0e48 }, // 72 , 14
|
|
{ 0x067E, 0x0e38 }, // 56 , 14
|
|
{ 0x067F, 0x0e44 }, // 68 , 14
|
|
{ 0x0680, 0x0e34 }, // 52 , 14
|
|
{ 0x0681, 0x0e64 }, // 100, 14
|
|
{ 0x0683, 0x0e54 }, // 84 , 14
|
|
{ 0x0684, 0x0e50 }, // 80 , 14
|
|
{ 0x0685, 0x0e60 }, // 96 , 14
|
|
{ 0x0686, 0x0e58 }, // 88 , 14
|
|
{ 0x0687, 0x0e5c }, // 92 , 14
|
|
{ 0x0688, 0x0e68 }, // 104, 14
|
|
{ 0x0689, 0x0e6a }, // 106, 14
|
|
{ 0x068A, 0x0e70 }, // 112, 14
|
|
{ 0x068C, 0x0e6c }, // 108, 14
|
|
{ 0x068D, 0x0e72 }, // 114, 14
|
|
{ 0x068E, 0x0e6e }, // 110, 14
|
|
{ 0x0691, 0x0e76 }, // 118, 14
|
|
{ 0x0692, 0x0e7C }, // 124, 14
|
|
{ 0x0693, 0x0e74 }, // 116, 14
|
|
{ 0x0695, 0x0e7a }, // 122, 14
|
|
{ 0x0696, 0x0e80 }, // 128, 14
|
|
{ 0x0698, 0x0e7e }, // 126, 14
|
|
{ 0x0699, 0x0e78 }, // 120, 14
|
|
{ 0x069A, 0x0e84 }, // 132, 14
|
|
{ 0x06A0, 0x0e88 }, // 136, 14
|
|
{ 0x06A4, 0x0e8c }, // 140, 14
|
|
{ 0x06A6, 0x0e90 }, // 144, 14
|
|
{ 0x06A9, 0x0e94 }, // 148, 14
|
|
{ 0x06AA, 0x0e9c }, // 156, 14
|
|
{ 0x06AB, 0x0ea8 }, // 168, 14
|
|
{ 0x06AF, 0x0ea0 }, // 160, 14
|
|
{ 0x06B1, 0x0eac }, // 172, 14
|
|
{ 0x06B3, 0x0eb0 }, // 176, 14
|
|
{ 0x06B5, 0x0eb4 }, // 180, 14
|
|
{ 0x06BA, 0x0eba }, // 186, 14
|
|
{ 0x06BB, 0x0ec2 }, // 194, 14
|
|
{ 0x06BC, 0x0ebe }, // 190, 14
|
|
{ 0x06C0, 0x0eda }, // 218, 14
|
|
{ 0x06C6, 0x0ec6 }, // 198, 14
|
|
{ 0x06CA, 0x0ec8 }, // 200, 14
|
|
{ 0x06CE, 0x0ed0 }, // 208, 14
|
|
{ 0x06D1, 0x0ed6 }, // 214, 14
|
|
{ 0x06D2, 0x0ed4 }, // 212, 14
|
|
{ 0x06D6, 0x0d25 }, // 37 , 13
|
|
{ 0x06E4, 0x0d22 }, // 34 , 13
|
|
{ 0x06F4, 0x0e29 }, // 41 , 14
|
|
{ 0x06F5, 0x0e2b }, // 43 , 14
|
|
{ 0x06F6, 0x0e2c }, // 44 , 14
|
|
{ 0x06F7, 0x0e2e }, // 46 , 14
|
|
{ 0x06F8, 0x0e2f }, // 47 , 14
|
|
{ 0x10D0, 0x0ad2 }, // 210, 10
|
|
{ 0x10D1, 0x0ad3 }, // 211, 10
|
|
{ 0x10D2, 0x0ad4 }, // 212, 10
|
|
{ 0x10D3, 0x0ad5 }, // 213, 10
|
|
{ 0x10D4, 0x0ad6 }, // 214, 10
|
|
{ 0x10D5, 0x0ad7 }, // 215, 10
|
|
{ 0x10D6, 0x0ad8 }, // 216, 10
|
|
{ 0x10D7, 0x0ada }, // 218, 10
|
|
{ 0x10D8, 0x0adb }, // 219, 10
|
|
{ 0x10D9, 0x0adc }, // 220, 10
|
|
{ 0x10DA, 0x0add }, // 221, 10
|
|
{ 0x10DB, 0x0ade }, // 222, 10
|
|
{ 0x10DC, 0x0adf }, // 223, 10
|
|
{ 0x10DD, 0x0ae1 }, // 225, 10
|
|
{ 0x10DE, 0x0ae2 }, // 226, 10
|
|
{ 0x10DF, 0x0ae3 }, // 227, 10
|
|
{ 0x10E0, 0x0ae4 }, // 228, 10
|
|
{ 0x10E1, 0x0ae5 }, // 229, 10
|
|
{ 0x10E2, 0x0ae6 }, // 230, 10
|
|
{ 0x10E3, 0x0ae7 }, // 231, 10
|
|
{ 0x10E4, 0x0ae9 }, // 233, 10
|
|
{ 0x10E5, 0x0aea }, // 234, 10
|
|
{ 0x10E6, 0x0aeb }, // 235, 10
|
|
{ 0x10E7, 0x0aec }, // 236, 10
|
|
{ 0x10E8, 0x0aed }, // 237, 10
|
|
{ 0x10E9, 0x0aee }, // 238, 10
|
|
{ 0x10EA, 0x0aef }, // 239, 10
|
|
{ 0x10EB, 0x0af0 }, // 240, 10
|
|
{ 0x10EC, 0x0af1 }, // 241, 10
|
|
{ 0x10ED, 0x0af2 }, // 242, 10
|
|
{ 0x10EE, 0x0af3 }, // 243, 10
|
|
{ 0x10EF, 0x0af5 }, // 245, 10
|
|
{ 0x10F0, 0x0af6 }, // 246, 10
|
|
{ 0x10F1, 0x0ad9 }, // 217, 10
|
|
{ 0x10F2, 0x0ae0 }, // 224, 10
|
|
{ 0x10F3, 0x0ae8 }, // 232, 10
|
|
{ 0x10F4, 0x0af4 }, // 244, 10
|
|
{ 0x10F5, 0x0af7 }, // 247, 10
|
|
{ 0x10F6, 0x0af8 }, // 248, 10
|
|
{ 0x1F00, 0x0873 }, // 115, 8
|
|
{ 0x1F01, 0x087b }, // 123, 8
|
|
{ 0x1F02, 0x0875 }, // 117, 8
|
|
{ 0x1F03, 0x087d }, // 125, 8
|
|
{ 0x1F04, 0x0874 }, // 116, 8
|
|
{ 0x1F05, 0x087c }, // 124, 8
|
|
{ 0x1F10, 0x0884 }, // 132, 8
|
|
{ 0x1F11, 0x0887 }, // 135, 8
|
|
{ 0x1F12, 0x0886 }, // 134, 8
|
|
{ 0x1F13, 0x0889 }, // 137, 8
|
|
{ 0x1F14, 0x0885 }, // 133, 8
|
|
{ 0x1F15, 0x0888 }, // 136, 8
|
|
{ 0x1F20, 0x0890 }, // 144, 8
|
|
{ 0x1F21, 0x0898 }, // 152, 8
|
|
{ 0x1F22, 0x0892 }, // 146, 8
|
|
{ 0x1F23, 0x089a }, // 154, 8
|
|
{ 0x1F24, 0x0891 }, // 145, 8
|
|
{ 0x1F25, 0x0899 }, // 153, 8
|
|
{ 0x1F30, 0x08a4 }, // 164, 8
|
|
{ 0x1F31, 0x08a8 }, // 168, 8
|
|
{ 0x1F32, 0x08a6 }, // 166, 8
|
|
{ 0x1F33, 0x08aa }, // 170, 8
|
|
{ 0x1F34, 0x08a5 }, // 165, 8
|
|
{ 0x1F35, 0x08a9 }, // 169, 8
|
|
{ 0x1F40, 0x08ad }, // 173, 8
|
|
{ 0x1F41, 0x08b0 }, // 176, 8
|
|
{ 0x1F42, 0x08af }, // 175, 8
|
|
{ 0x1F43, 0x08b2 }, // 178, 8
|
|
{ 0x1F44, 0x08ae }, // 174, 8
|
|
{ 0x1F45, 0x08b1 }, // 177, 8
|
|
{ 0x1F50, 0x08b9 }, // 185, 8
|
|
{ 0x1F51, 0x08bd }, // 189, 8
|
|
{ 0x1F52, 0x08bb }, // 187, 8
|
|
{ 0x1F53, 0x08bf }, // 191, 8
|
|
{ 0x1F54, 0x08ba }, // 186, 8
|
|
{ 0x1F55, 0x08be }, // 190, 8
|
|
{ 0x1F60, 0x08c7 }, // 199, 8
|
|
{ 0x1F61, 0x08cf }, // 207, 8
|
|
{ 0x1F62, 0x08c9 }, // 201, 8
|
|
{ 0x1F63, 0x08d1 }, // 209, 8
|
|
{ 0x1F64, 0x08c8 }, // 200, 8
|
|
{ 0x1F65, 0x08d0 }, // 208, 8
|
|
{ 0x1F70, 0x086d }, // 109, 8
|
|
{ 0x1F72, 0x0883 }, // 131, 8
|
|
{ 0x1F74, 0x088a }, // 138, 8
|
|
{ 0x1F76, 0x08a0 }, // 160, 8
|
|
{ 0x1F78, 0x08ac }, // 172, 8
|
|
{ 0x1F7A, 0x08b5 }, // 181, 8
|
|
{ 0x1F7C, 0x08c1 }, // 193, 8
|
|
{ 0x1F80, 0x0877 }, // 119, 8
|
|
{ 0x1F81, 0x087f }, // 127, 8
|
|
{ 0x1F82, 0x0879 }, // 121, 8
|
|
{ 0x1F83, 0x0881 }, // 129, 8
|
|
{ 0x1F84, 0x0878 }, // 120, 8
|
|
{ 0x1F85, 0x0880 }, // 128, 8
|
|
{ 0x1F90, 0x0894 }, // 148, 8
|
|
{ 0x1F91, 0x089c }, // 156, 8
|
|
{ 0x1F92, 0x0896 }, // 150, 8
|
|
{ 0x1F93, 0x089e }, // 158, 8
|
|
{ 0x1F94, 0x0895 }, // 149, 8
|
|
{ 0x1F95, 0x089d }, // 157, 8
|
|
{ 0x1FA0, 0x08cb }, // 203, 8
|
|
{ 0x1FA1, 0x08d3 }, // 211, 8
|
|
{ 0x1FA2, 0x08cd }, // 205, 8
|
|
{ 0x1FA3, 0x08d5 }, // 213, 8
|
|
{ 0x1FA4, 0x08cc }, // 204, 8
|
|
{ 0x1FA5, 0x08d4 }, // 212, 8
|
|
{ 0x1FB2, 0x0871 }, // 113, 8
|
|
{ 0x1FB3, 0x086f }, // 111, 8
|
|
{ 0x1FB4, 0x0870 }, // 112, 8
|
|
{ 0x1FC2, 0x088e }, // 142, 8
|
|
{ 0x1FC3, 0x088c }, // 140, 8
|
|
{ 0x1FC4, 0x088d }, // 141, 8
|
|
{ 0x1FCD, 0x085e }, // 94 , 8
|
|
{ 0x1FCE, 0x085c }, // 92 , 8
|
|
{ 0x1FDD, 0x085f }, // 95 , 8
|
|
{ 0x1FDE, 0x085d }, // 93 , 8
|
|
{ 0x1FE4, 0x08B4 }, // 180, 8
|
|
{ 0x1FE5, 0x08B3 }, // 179, 8
|
|
{ 0x1FF2, 0x08c5 }, // 197, 8
|
|
{ 0x1FF3, 0x08c3 }, // 195, 8
|
|
{ 0x1FF4, 0x08c4 }, // 196, 8
|
|
{ 0x2007, 0x0517 }, // 23 , 5
|
|
{ 0x2012, 0x0432 }, // 50 , 4
|
|
{ 0x2013, 0x0421 }, // 33 , 4
|
|
{ 0x2014, 0x0422 }, // 34 , 4
|
|
{ 0x2017, 0x022f }, // 47 , 2
|
|
{ 0x2018, 0x041d }, // 29 , 4
|
|
{ 0x2019, 0x041c }, // 28 , 4
|
|
{ 0x201A, 0x043e }, // 62 , 4
|
|
{ 0x201B, 0x041b }, // 27 , 4
|
|
{ 0x201C, 0x0420 }, // 32 , 4
|
|
{ 0x201D, 0x041f }, // 31 , 4
|
|
{ 0x201E, 0x043f }, // 63 , 4
|
|
{ 0x201F, 0x041e }, // 30 , 4
|
|
{ 0x2020, 0x0427 }, // 39 , 4
|
|
{ 0x2021, 0x0428 }, // 40 , 4
|
|
{ 0x2022, 0x0403 }, // 3 , 4
|
|
{ 0x2026, 0x0438 }, // 56 , 4
|
|
{ 0x2030, 0x044b }, // 75 , 4
|
|
{ 0x2033, 0x0580 }, // 128, 5
|
|
{ 0x2034, 0x0671 }, // 113, 6
|
|
{ 0x2036, 0x057f }, // 127, 5
|
|
{ 0x2039, 0x0423 }, // 35 , 4
|
|
{ 0x203A, 0x0424 }, // 36 , 4
|
|
{ 0x203C, 0x050d }, // 13 , 5
|
|
{ 0x203E, 0x0626 }, // 38 , 6
|
|
{ 0x207F, 0x0415 }, // 21 , 4
|
|
{ 0x20A0, 0x043c }, // 60 , 4
|
|
{ 0x20A2, 0x043b }, // 59 , 4
|
|
{ 0x20A3, 0x043a }, // 58 , 4
|
|
{ 0x20A4, 0x043d }, // 61 , 4
|
|
{ 0x20A6, 0x0457 }, // 87 , 4
|
|
{ 0x20A7, 0x040d }, // 13 , 4
|
|
{ 0x20A8, 0x0458 }, // 88 , 4
|
|
{ 0x20A9, 0x0456 }, // 86 , 4
|
|
{ 0x20AA, 0x097A }, // 122, 9
|
|
{ 0x20AC, 0x0466 }, // 102, 4, Euro Sign - GW assigned x448 [4,72]
|
|
{ 0x20DD, 0x066d }, // 109, 6
|
|
{ 0x20E1, 0x06e1 }, // 225, 6
|
|
{ 0x2102, 0x06d5 }, // 213, 6
|
|
{ 0x2104, 0x0515 }, // 21 , 5
|
|
{ 0x2105, 0x0449 }, // 73 , 4
|
|
{ 0x2106, 0x044a }, // 74 , 4
|
|
{ 0x210C, 0x06e9 }, // 233, 6
|
|
{ 0x210F, 0x0632 }, // 50 , 6
|
|
{ 0x2111, 0x0633 }, // 51 , 6
|
|
{ 0x2112, 0x0669 }, // 105, 6
|
|
{ 0x2113, 0x0631 }, // 49 , 6
|
|
{ 0x2115, 0x06d7 }, // 215, 6
|
|
{ 0x2116, 0x044c }, // 76 , 4
|
|
{ 0x2118, 0x0635 }, // 53 , 6
|
|
{ 0x211C, 0x0634 }, // 52 , 6
|
|
{ 0x211D, 0x06d8 }, // 216, 6
|
|
{ 0x211E, 0x042b }, // 43 , 4
|
|
{ 0x2120, 0x042a }, // 42 , 4
|
|
{ 0x2122, 0x0429 }, // 41 , 4
|
|
{ 0x2127, 0x06a7 }, // 167, 6
|
|
{ 0x2128, 0x066b }, // 107, 6
|
|
{ 0x212B, 0x0623 }, // 35 , 6
|
|
{ 0x212D, 0x066a }, // 106, 6
|
|
{ 0x212F, 0x0630 }, // 48 , 6
|
|
{ 0x2130, 0x06d3 }, // 211, 6
|
|
{ 0x2131, 0x06d4 }, // 212, 6
|
|
{ 0x2153, 0x0440 }, // 64 , 4
|
|
{ 0x2154, 0x0441 }, // 65 , 4
|
|
{ 0x215B, 0x0442 }, // 66 , 4
|
|
{ 0x215C, 0x0443 }, // 67 , 4
|
|
{ 0x215D, 0x0444 }, // 68 , 4
|
|
{ 0x215E, 0x0445 }, // 69 , 4
|
|
{ 0x2190, 0x0590 }, // 144, 5
|
|
{ 0x2191, 0x0617 }, // 23 , 6
|
|
{ 0x2192, 0x05d5 }, // 213, 5
|
|
{ 0x2193, 0x0618 }, // 24 , 6
|
|
{ 0x2194, 0x05d6 }, // 214, 5
|
|
{ 0x2195, 0x05d7 }, // 215, 5
|
|
{ 0x2196, 0x0640 }, // 64 , 6
|
|
{ 0x2197, 0x063e }, // 62 , 6
|
|
{ 0x2198, 0x063f }, // 63 , 6
|
|
{ 0x2199, 0x0641 }, // 65 , 6
|
|
{ 0x219D, 0x0690 }, // 144, 6
|
|
{ 0x21A3, 0x0693 }, // 147, 6
|
|
{ 0x21A8, 0x050f }, // 15 , 5
|
|
{ 0x21A9, 0x0691 }, // 145, 6
|
|
{ 0x21AA, 0x0692 }, // 146, 6
|
|
{ 0x21B5, 0x0514 }, // 20 , 5
|
|
{ 0x21BC, 0x0694 }, // 148, 6
|
|
{ 0x21BD, 0x0695 }, // 149, 6
|
|
{ 0x21BE, 0x069b }, // 155, 6
|
|
{ 0x21BF, 0x069a }, // 154, 6
|
|
{ 0x21C0, 0x0696 }, // 150, 6
|
|
{ 0x21C1, 0x0697 }, // 151, 6
|
|
{ 0x21C2, 0x069d }, // 157, 6
|
|
{ 0x21C3, 0x069c }, // 156, 6
|
|
{ 0x21C4, 0x0636 }, // 54 , 6
|
|
{ 0x21C6, 0x0637 }, // 55 , 6
|
|
{ 0x21C7, 0x069f }, // 159, 6
|
|
{ 0x21C9, 0x069e }, // 158, 6
|
|
{ 0x21CB, 0x0699 }, // 153, 6
|
|
{ 0x21CC, 0x0698 }, // 152, 6
|
|
{ 0x21D0, 0x0639 }, // 57 , 6
|
|
{ 0x21D1, 0x063a }, // 58 , 6
|
|
{ 0x21D2, 0x0638 }, // 56 , 6
|
|
{ 0x21D3, 0x063b }, // 59 , 6
|
|
{ 0x21D4, 0x063c }, // 60 , 6
|
|
{ 0x21D5, 0x063d }, // 61 , 6
|
|
{ 0x21E6, 0x0597 }, // 151, 5
|
|
{ 0x21E8, 0x0596 }, // 150, 5
|
|
{ 0x2200, 0x067a }, // 122, 6
|
|
{ 0x2202, 0x062c }, // 44 , 6
|
|
{ 0x2203, 0x0679 }, // 121, 6
|
|
{ 0x2204, 0x06d0 }, // 208, 6
|
|
{ 0x2205, 0x0648 }, // 72 , 6
|
|
{ 0x2207, 0x062b }, // 43 , 6
|
|
{ 0x2208, 0x060f }, // 15 , 6
|
|
{ 0x2209, 0x06d1 }, // 209, 6
|
|
{ 0x220B, 0x06db }, // 219, 6
|
|
{ 0x220D, 0x0647 }, // 71 , 6
|
|
{ 0x220F, 0x0629 }, // 41 , 6
|
|
{ 0x2210, 0x0672 }, // 114, 6
|
|
{ 0x2211, 0x0612 }, // 18 , 6
|
|
{ 0x2212, 0x0600 }, // 0 , 6
|
|
{ 0x2213, 0x062a }, // 42 , 6
|
|
{ 0x2214, 0x06ae }, // 174, 6
|
|
{ 0x2215, 0x0606 }, // 6 , 6
|
|
{ 0x2216, 0x0607 }, // 7 , 6
|
|
{ 0x2218, 0x0621 }, // 33 , 6
|
|
{ 0x2219, 0x0622 }, // 34 , 6
|
|
{ 0x221A, 0x0704 }, // 4 , 7
|
|
{ 0x221D, 0x0604 }, // 4 , 6
|
|
{ 0x221E, 0x0613 }, // 19 , 6
|
|
{ 0x221F, 0x06da }, // 218, 6
|
|
{ 0x2220, 0x064f }, // 79 , 6
|
|
{ 0x2221, 0x06a8 }, // 168, 6
|
|
{ 0x2222, 0x06a9 }, // 169, 6
|
|
{ 0x2223, 0x0609 }, // 9 , 6
|
|
{ 0x2224, 0x06ce }, // 206, 6
|
|
{ 0x2225, 0x0611 }, // 17 , 6
|
|
{ 0x2226, 0x06cd }, // 205, 6
|
|
{ 0x2227, 0x0655 }, // 85 , 6
|
|
{ 0x2228, 0x0656 }, // 86 , 6
|
|
{ 0x2229, 0x0610 }, // 16 , 6
|
|
{ 0x222A, 0x0642 }, // 66 , 6
|
|
{ 0x222B, 0x0628 }, // 40 , 6
|
|
{ 0x222E, 0x0668 }, // 104, 6
|
|
{ 0x2234, 0x0666 }, // 102, 6
|
|
{ 0x2235, 0x0665 }, // 101, 6
|
|
{ 0x2237, 0x0667 }, // 103, 6
|
|
{ 0x223C, 0x060c }, // 12 , 6
|
|
{ 0x2241, 0x06bd }, // 189, 6
|
|
{ 0x2243, 0x0673 }, // 115, 6
|
|
{ 0x2244, 0x06be }, // 190, 6
|
|
{ 0x2245, 0x0674 }, // 116, 6
|
|
{ 0x2247, 0x06bf }, // 191, 6
|
|
{ 0x2248, 0x060d }, // 13 , 6
|
|
{ 0x2249, 0x06c0 }, // 192, 6
|
|
{ 0x224D, 0x06b3 }, // 179, 6
|
|
{ 0x224E, 0x06b2 }, // 178, 6
|
|
{ 0x2250, 0x06af }, // 175, 6
|
|
{ 0x2252, 0x06b0 }, // 176, 6
|
|
{ 0x2253, 0x06b1 }, // 177, 6
|
|
{ 0x225F, 0x06d9 }, // 217, 6
|
|
{ 0x2260, 0x0663 }, // 99 , 6
|
|
{ 0x2261, 0x060e }, // 14 , 6
|
|
{ 0x2262, 0x0664 }, // 100, 6
|
|
{ 0x2264, 0x0602 }, // 2 , 6
|
|
{ 0x2265, 0x0603 }, // 3 , 6
|
|
{ 0x226A, 0x064d }, // 77 , 6
|
|
{ 0x226B, 0x064e }, // 78 , 6
|
|
{ 0x226C, 0x06b6 }, // 182, 6
|
|
{ 0x226D, 0x06cf }, // 207, 6
|
|
{ 0x226E, 0x06b9 }, // 185, 6
|
|
{ 0x226F, 0x06bb }, // 187, 6
|
|
{ 0x2270, 0x06ba }, // 186, 6
|
|
{ 0x2271, 0x06bc }, // 188, 6
|
|
{ 0x2272, 0x06eb }, // 235, 6
|
|
{ 0x2273, 0x06ec }, // 236, 6
|
|
{ 0x227A, 0x0675 }, // 117, 6
|
|
{ 0x227B, 0x0677 }, // 119, 6
|
|
{ 0x227C, 0x0676 }, // 118, 6
|
|
{ 0x227D, 0x0678 }, // 120, 6
|
|
{ 0x2280, 0x06c1 }, // 193, 6
|
|
{ 0x2281, 0x06c3 }, // 195, 6
|
|
{ 0x2282, 0x0643 }, // 67 , 6
|
|
{ 0x2283, 0x0644 }, // 68 , 6
|
|
{ 0x2284, 0x06c5 }, // 197, 6
|
|
{ 0x2285, 0x06c6 }, // 198, 6
|
|
{ 0x2286, 0x0645 }, // 69 , 6
|
|
{ 0x2287, 0x0646 }, // 70 , 6
|
|
{ 0x2288, 0x06c7 }, // 199, 6
|
|
{ 0x2289, 0x06c8 }, // 200, 6
|
|
{ 0x228A, 0x067e }, // 126, 6
|
|
{ 0x228B, 0x067f }, // 127, 6
|
|
{ 0x228E, 0x067d }, // 125, 6
|
|
{ 0x228F, 0x0682 }, // 130, 6
|
|
{ 0x2290, 0x0685 }, // 133, 6
|
|
{ 0x2291, 0x0683 }, // 131, 6
|
|
{ 0x2292, 0x0686 }, // 134, 6
|
|
{ 0x2293, 0x0680 }, // 128, 6
|
|
{ 0x2294, 0x0681 }, // 129, 6
|
|
{ 0x2295, 0x0651 }, // 81 , 6
|
|
{ 0x2296, 0x0652 }, // 82 , 6
|
|
{ 0x2297, 0x0650 }, // 80 , 6
|
|
{ 0x2299, 0x0654 }, // 84 , 6
|
|
{ 0x229A, 0x06a4 }, // 164, 6
|
|
{ 0x229B, 0x06a5 }, // 165, 6
|
|
{ 0x229D, 0x06a6 }, // 166, 6
|
|
{ 0x22A2, 0x065b }, // 91 , 6
|
|
{ 0x22A3, 0x065c }, // 92 , 6
|
|
{ 0x22A4, 0x0658 }, // 88 , 6
|
|
{ 0x22A5, 0x0659 }, // 89 , 6
|
|
{ 0x22A8, 0x06b4 }, // 180, 6
|
|
{ 0x22BB, 0x0657 }, // 87 , 6
|
|
{ 0x22C5, 0x061f }, // 31 , 6
|
|
{ 0x22C6, 0x0670 }, // 112, 6
|
|
{ 0x22C8, 0x068c }, // 140, 6
|
|
{ 0x22D0, 0x06a2 }, // 162, 6
|
|
{ 0x22D1, 0x06a3 }, // 163, 6
|
|
{ 0x22D2, 0x06a1 }, // 161, 6
|
|
{ 0x22D3, 0x06a0 }, // 160, 6
|
|
{ 0x22D8, 0x067b }, // 123, 6
|
|
{ 0x22D9, 0x067c }, // 124, 6
|
|
{ 0x22E0, 0x06c2 }, // 194, 6
|
|
{ 0x22E1, 0x06c4 }, // 196, 6
|
|
{ 0x22E2, 0x06cb }, // 203, 6
|
|
{ 0x22E3, 0x06cc }, // 204, 6
|
|
{ 0x22E4, 0x0684 }, // 132, 6
|
|
{ 0x22E5, 0x0687 }, // 135, 6
|
|
{ 0x22EE, 0x06de }, // 222, 6
|
|
{ 0x22EF, 0x06dc }, // 220, 6
|
|
{ 0x22F1, 0x06df }, // 223, 6
|
|
{ 0x2302, 0x050c }, // 12 , 5
|
|
{ 0x2308, 0x0649 }, // 73 , 6
|
|
{ 0x2309, 0x064a }, // 74 , 6
|
|
{ 0x230A, 0x064b }, // 75 , 6
|
|
{ 0x230B, 0x064c }, // 76 , 6
|
|
{ 0x2310, 0x0510 }, // 16 , 5
|
|
{ 0x2312, 0x065a }, // 90 , 6
|
|
{ 0x2319, 0x0511 }, // 17 , 5
|
|
{ 0x231A, 0x051f }, // 31 , 5
|
|
{ 0x231B, 0x0520 }, // 32 , 5
|
|
{ 0x2320, 0x0700 }, // 0 , 7
|
|
{ 0x2321, 0x0701 }, // 1 , 7
|
|
{ 0x2322, 0x068e }, // 142, 6
|
|
{ 0x2323, 0x068d }, // 141, 6
|
|
{ 0x2329, 0x060a }, // 10 , 6
|
|
{ 0x232A, 0x060b }, // 11 , 6
|
|
{ 0x2409, 0x044f }, // 79 , 4
|
|
{ 0x240A, 0x0452 }, // 82 , 4
|
|
{ 0x240B, 0x0454 }, // 84 , 4
|
|
{ 0x240C, 0x0450 }, // 80 , 4
|
|
{ 0x240D, 0x0451 }, // 81 , 4
|
|
{ 0x2424, 0x0453 }, // 83 , 4
|
|
{ 0x24C2, 0x0446 }, // 70 , 4
|
|
{ 0x24C5, 0x0447 }, // 71 , 4
|
|
{ 0x24CA, 0x0448 }, // 72 , 4, - circled U
|
|
{ 0x2500, 0x0308 }, // 8 , 3
|
|
{ 0x2502, 0x0309 }, // 9 , 3
|
|
{ 0x250C, 0x030a }, // 10 , 3
|
|
{ 0x2510, 0x030b }, // 11 , 3
|
|
{ 0x2514, 0x030d }, // 13 , 3
|
|
{ 0x2518, 0x030c }, // 12 , 3
|
|
{ 0x251C, 0x030e }, // 14 , 3
|
|
{ 0x251E, 0x033e }, // 62 , 3
|
|
{ 0x251F, 0x033c }, // 60 , 3
|
|
{ 0x2521, 0x033f }, // 63 , 3
|
|
{ 0x2522, 0x033d }, // 61 , 3
|
|
{ 0x2524, 0x0310 }, // 16 , 3
|
|
{ 0x2526, 0x0345 }, // 69 , 3
|
|
{ 0x2527, 0x0344 }, // 68 , 3
|
|
{ 0x2529, 0x0347 }, // 71 , 3
|
|
{ 0x252A, 0x0346 }, // 70 , 3
|
|
{ 0x252C, 0x030f }, // 15 , 3
|
|
{ 0x252D, 0x0342 }, // 66 , 3
|
|
{ 0x252E, 0x0340 }, // 64 , 3
|
|
{ 0x2531, 0x0343 }, // 67 , 3
|
|
{ 0x2532, 0x0341 }, // 65 , 3
|
|
{ 0x2534, 0x0311 }, // 17 , 3
|
|
{ 0x2535, 0x034a }, // 74 , 3
|
|
{ 0x2536, 0x0348 }, // 72 , 3
|
|
{ 0x2539, 0x034b }, // 75 , 3
|
|
{ 0x253A, 0x0349 }, // 73 , 3
|
|
{ 0x253C, 0x0312 }, // 18 , 3
|
|
{ 0x253D, 0x0352 }, // 82 , 3
|
|
{ 0x253E, 0x034e }, // 78 , 3
|
|
{ 0x2540, 0x034f }, // 79 , 3
|
|
{ 0x2541, 0x034c }, // 76 , 3
|
|
{ 0x2543, 0x0355 }, // 85 , 3
|
|
{ 0x2544, 0x0350 }, // 80 , 3
|
|
{ 0x2545, 0x0353 }, // 83 , 3
|
|
{ 0x2546, 0x034d }, // 77 , 3
|
|
{ 0x2547, 0x0357 }, // 87 , 3
|
|
{ 0x2548, 0x0354 }, // 84 , 3
|
|
{ 0x2549, 0x0356 }, // 86 , 3
|
|
{ 0x254A, 0x0351 }, // 81 , 3
|
|
{ 0x2550, 0x0313 }, // 19 , 3
|
|
{ 0x2551, 0x0314 }, // 20 , 3
|
|
{ 0x2552, 0x031e }, // 30 , 3
|
|
{ 0x2553, 0x0322 }, // 34 , 3
|
|
{ 0x2554, 0x0315 }, // 21 , 3
|
|
{ 0x2555, 0x031f }, // 31 , 3
|
|
{ 0x2556, 0x0323 }, // 35 , 3
|
|
{ 0x2557, 0x0316 }, // 22 , 3
|
|
{ 0x2558, 0x0321 }, // 33 , 3
|
|
{ 0x2559, 0x0325 }, // 37 , 3
|
|
{ 0x255A, 0x0318 }, // 24 , 3
|
|
{ 0x255B, 0x0320 }, // 32 , 3
|
|
{ 0x255C, 0x0324 }, // 36 , 3
|
|
{ 0x255D, 0x0317 }, // 23 , 3
|
|
{ 0x255E, 0x0326 }, // 38 , 3
|
|
{ 0x255F, 0x032a }, // 42 , 3
|
|
{ 0x2560, 0x0319 }, // 25 , 3
|
|
{ 0x2561, 0x0328 }, // 40 , 3
|
|
{ 0x2562, 0x032c }, // 44 , 3
|
|
{ 0x2563, 0x031b }, // 27 , 3
|
|
{ 0x2564, 0x032b }, // 43 , 3
|
|
{ 0x2565, 0x0327 }, // 39 , 3
|
|
{ 0x2566, 0x031a }, // 26 , 3
|
|
{ 0x2567, 0x032d }, // 45 , 3
|
|
{ 0x2568, 0x0329 }, // 41 , 3
|
|
{ 0x2569, 0x031c }, // 28 , 3
|
|
{ 0x256A, 0x032f }, // 47 , 3
|
|
{ 0x256B, 0x032e }, // 46 , 3
|
|
{ 0x256C, 0x031d }, // 29 , 3
|
|
{ 0x2574, 0x0330 }, // 48 , 3
|
|
{ 0x2575, 0x0331 }, // 49 , 3
|
|
{ 0x2576, 0x0332 }, // 50 , 3
|
|
{ 0x2577, 0x0333 }, // 51 , 3
|
|
{ 0x2578, 0x0334 }, // 52 , 3
|
|
{ 0x2579, 0x0335 }, // 53 , 3
|
|
{ 0x257A, 0x0336 }, // 54 , 3
|
|
{ 0x257B, 0x0337 }, // 55 , 3
|
|
{ 0x257C, 0x0338 }, // 56 , 3
|
|
{ 0x257D, 0x033a }, // 58 , 3
|
|
{ 0x257E, 0x0339 }, // 57 , 3
|
|
{ 0x257F, 0x033b }, // 59 , 3
|
|
{ 0x2580, 0x0305 }, // 5 , 3
|
|
{ 0x2584, 0x0307 }, // 7 , 3
|
|
{ 0x2588, 0x0303 }, // 3 , 3
|
|
{ 0x258C, 0x0304 }, // 4 , 3
|
|
{ 0x2590, 0x0306 }, // 6 , 3
|
|
{ 0x2591, 0x0300 }, // 0 , 3
|
|
{ 0x2592, 0x0301 }, // 1 , 3
|
|
{ 0x2593, 0x0302 }, // 2 , 3
|
|
{ 0x25A0, 0x0402 }, // 2 , 4
|
|
{ 0x25A1, 0x0426 }, // 38 , 4
|
|
{ 0x25AA, 0x042f }, // 47 , 4
|
|
{ 0x25AB, 0x0431 }, // 49 , 4
|
|
{ 0x25AC, 0x050b }, // 11 , 5
|
|
{ 0x25B2, 0x0573 }, // 115, 5
|
|
{ 0x25B3, 0x0688 }, // 136, 6
|
|
{ 0x25B4, 0x061d }, // 29 , 6
|
|
{ 0x25B5, 0x06ac }, // 172, 6
|
|
{ 0x25B8, 0x061b }, // 27 , 6
|
|
{ 0x25B9, 0x068b }, // 139, 6
|
|
{ 0x25BC, 0x0574 }, // 116, 5
|
|
{ 0x25BD, 0x0689 }, // 137, 6
|
|
{ 0x25BE, 0x061e }, // 30 , 6
|
|
{ 0x25BF, 0x06ad }, // 173, 6
|
|
{ 0x25C2, 0x061c }, // 28 , 6
|
|
{ 0x25C3, 0x068a }, // 138, 6
|
|
{ 0x25C6, 0x0575 }, // 117, 5
|
|
{ 0x25C7, 0x066f }, // 111, 6
|
|
{ 0x25CA, 0x065f }, // 95 , 6
|
|
{ 0x25CB, 0x0401 }, // 1 , 4
|
|
{ 0x25CF, 0x0400 }, // 0 , 4
|
|
{ 0x25D6, 0x059e }, // 158, 5
|
|
{ 0x25D7, 0x0577 }, // 119, 5
|
|
{ 0x25D8, 0x0512 }, // 18 , 5
|
|
{ 0x25D9, 0x0513 }, // 19 , 5
|
|
{ 0x25E6, 0x042d }, // 45 , 4
|
|
{ 0x2605, 0x0548 }, // 72, 5
|
|
{ 0x260E, 0x051e }, // 30 , 5
|
|
{ 0x2610, 0x0518 }, // 24 , 5
|
|
{ 0x2612, 0x0519 }, // 25 , 5
|
|
{ 0x261B, 0x052a }, // 42 , 5
|
|
{ 0x261C, 0x0516 }, // 22 , 5
|
|
{ 0x261E, 0x052b }, // 43 , 5
|
|
{ 0x2639, 0x051a }, // 26 , 5
|
|
{ 0x263A, 0x0507 }, // 7 , 5
|
|
{ 0x263B, 0x0508 }, // 8 , 5
|
|
{ 0x263C, 0x0506 }, // 6 , 5
|
|
{ 0x2640, 0x0505 }, // 5 , 5
|
|
{ 0x2642, 0x0504 }, // 4 , 5
|
|
{ 0x2660, 0x05ab }, // 171, 5
|
|
{ 0x2661, 0x0500 }, // 0 , 5
|
|
{ 0x2662, 0x0501 }, // 1 , 5
|
|
{ 0x2663, 0x05a8 }, // 168, 5
|
|
{ 0x2664, 0x0503 }, // 3 , 5
|
|
{ 0x2665, 0x05aa }, // 170, 5
|
|
{ 0x2666, 0x05a9 }, // 169, 5
|
|
{ 0x2667, 0x0502 }, // 2 , 5
|
|
{ 0x266A, 0x0509 }, // 9 , 5
|
|
{ 0x266C, 0x050a }, // 10 , 5
|
|
{ 0x266D, 0x051c }, // 28 , 5
|
|
{ 0x266E, 0x051d }, // 29 , 5
|
|
{ 0x266F, 0x051b }, // 27 , 5
|
|
{ 0x2701, 0x0521 }, // 33 , 5
|
|
{ 0x2702, 0x0522 }, // 34 , 5
|
|
{ 0x2703, 0x0523 }, // 35 , 5
|
|
{ 0x2704, 0x0524 }, // 36 , 5
|
|
{ 0x2706, 0x0526 }, // 38 , 5
|
|
{ 0x2707, 0x0527 }, // 39 , 5
|
|
{ 0x2708, 0x0528 }, // 40 , 5
|
|
{ 0x2709, 0x0529 }, // 41 , 5
|
|
{ 0x270C, 0x052c }, // 44 , 5
|
|
{ 0x270D, 0x052d }, // 45 , 5
|
|
{ 0x270E, 0x052e }, // 46 , 5
|
|
{ 0x270F, 0x052f }, // 47 , 5
|
|
{ 0x2710, 0x0530 }, // 48 , 5
|
|
{ 0x2711, 0x0531 }, // 49 , 5
|
|
{ 0x2712, 0x0532 }, // 50 , 5
|
|
{ 0x2713, 0x0533 }, // 51 , 5
|
|
{ 0x2714, 0x0534 }, // 52 , 5
|
|
{ 0x2715, 0x0535 }, // 53 , 5
|
|
{ 0x2716, 0x0536 }, // 54 , 5
|
|
{ 0x2717, 0x0537 }, // 55 , 5
|
|
{ 0x2718, 0x0538 }, // 56 , 5
|
|
{ 0x2719, 0x0539 }, // 57 , 5
|
|
{ 0x271A, 0x053a }, // 58 , 5
|
|
{ 0x271B, 0x053b }, // 59 , 5
|
|
{ 0x271C, 0x053c }, // 60 , 5
|
|
{ 0x271D, 0x053d }, // 61 , 5
|
|
{ 0x271E, 0x053e }, // 62 , 5
|
|
{ 0x271F, 0x053f }, // 63 , 5
|
|
{ 0x2720, 0x0540 }, // 64 , 5
|
|
{ 0x2721, 0x0541 }, // 65 , 5
|
|
{ 0x2722, 0x0542 }, // 66 , 5
|
|
{ 0x2723, 0x0543 }, // 67 , 5
|
|
{ 0x2724, 0x0544 }, // 68 , 5
|
|
{ 0x2725, 0x0545 }, // 69 , 5
|
|
{ 0x2726, 0x0546 }, // 70 , 5
|
|
{ 0x2727, 0x0547 }, // 71 , 5
|
|
{ 0x2729, 0x0549 }, // 73 , 5
|
|
{ 0x272A, 0x054a }, // 74 , 5
|
|
{ 0x272B, 0x054b }, // 75 , 5
|
|
{ 0x272C, 0x054c }, // 76 , 5
|
|
{ 0x272D, 0x054d }, // 77 , 5
|
|
{ 0x272E, 0x054e }, // 78 , 5
|
|
{ 0x272F, 0x054f }, // 79 , 5
|
|
{ 0x2730, 0x0550 }, // 80 , 5
|
|
{ 0x2731, 0x0551 }, // 81 , 5
|
|
{ 0x2732, 0x0552 }, // 82 , 5
|
|
{ 0x2733, 0x0553 }, // 83 , 5
|
|
{ 0x2734, 0x0554 }, // 84 , 5
|
|
{ 0x2735, 0x0555 }, // 85 , 5
|
|
{ 0x2736, 0x0556 }, // 86 , 5
|
|
{ 0x2737, 0x0557 }, // 87 , 5
|
|
{ 0x2738, 0x0558 }, // 88 , 5
|
|
{ 0x2739, 0x0559 }, // 89 , 5
|
|
{ 0x273A, 0x055a }, // 90 , 5
|
|
{ 0x273B, 0x055b }, // 91 , 5
|
|
{ 0x273C, 0x055c }, // 92 , 5
|
|
{ 0x273D, 0x055d }, // 93 , 5
|
|
{ 0x273E, 0x055e }, // 94 , 5
|
|
{ 0x273F, 0x055f }, // 95 , 5
|
|
{ 0x2740, 0x0560 }, // 96 , 5
|
|
{ 0x2741, 0x0561 }, // 97 , 5
|
|
{ 0x2742, 0x0562 }, // 98 , 5
|
|
{ 0x2743, 0x0563 }, // 99 , 5
|
|
{ 0x2744, 0x0564 }, // 100, 5
|
|
{ 0x2745, 0x0565 }, // 101, 5
|
|
{ 0x2746, 0x0566 }, // 102, 5
|
|
{ 0x2747, 0x0567 }, // 103, 5
|
|
{ 0x2748, 0x0568 }, // 104, 5
|
|
{ 0x2749, 0x0569 }, // 105, 5
|
|
{ 0x274A, 0x056a }, // 106, 5
|
|
{ 0x274B, 0x056b }, // 107, 5
|
|
{ 0x274D, 0x056d }, // 109, 5
|
|
{ 0x274F, 0x056f }, // 111, 5
|
|
{ 0x2750, 0x0570 }, // 112, 5
|
|
{ 0x2751, 0x0571 }, // 113, 5
|
|
{ 0x2752, 0x0572 }, // 114, 5
|
|
{ 0x2756, 0x0576 }, // 118, 5
|
|
{ 0x2758, 0x0578 }, // 120, 5
|
|
{ 0x2759, 0x0579 }, // 121, 5
|
|
{ 0x275A, 0x057a }, // 122, 5
|
|
{ 0x275B, 0x057b }, // 123, 5
|
|
{ 0x275C, 0x057c }, // 124, 5
|
|
{ 0x275D, 0x057d }, // 125, 5
|
|
{ 0x275E, 0x057e }, // 126, 5
|
|
{ 0x2761, 0x05a1 }, // 161, 5
|
|
{ 0x2762, 0x05a2 }, // 162, 5
|
|
{ 0x2763, 0x05a3 }, // 163, 5
|
|
{ 0x2764, 0x05a4 }, // 164, 5
|
|
{ 0x2765, 0x05a5 }, // 165, 5
|
|
{ 0x2766, 0x05a6 }, // 166, 5
|
|
{ 0x2767, 0x05a7 }, // 167, 5
|
|
{ 0x2776, 0x05b6 }, // 182, 5
|
|
{ 0x2777, 0x05b7 }, // 183, 5
|
|
{ 0x2778, 0x05b8 }, // 184, 5
|
|
{ 0x2779, 0x05b9 }, // 185, 5
|
|
{ 0x277A, 0x05ba }, // 186, 5
|
|
{ 0x277B, 0x05bb }, // 187, 5
|
|
{ 0x277C, 0x05bc }, // 188, 5
|
|
{ 0x277D, 0x05bd }, // 189, 5
|
|
{ 0x277E, 0x05be }, // 190, 5
|
|
{ 0x277F, 0x05bf }, // 191, 5
|
|
{ 0x2780, 0x05c0 }, // 192, 5
|
|
{ 0x2781, 0x05c1 }, // 193, 5
|
|
{ 0x2782, 0x05c2 }, // 194, 5
|
|
{ 0x2783, 0x05c3 }, // 195, 5
|
|
{ 0x2784, 0x05c4 }, // 196, 5
|
|
{ 0x2785, 0x05c5 }, // 197, 5
|
|
{ 0x2786, 0x05c6 }, // 198, 5
|
|
{ 0x2787, 0x05c7 }, // 199, 5
|
|
{ 0x2788, 0x05c8 }, // 200, 5
|
|
{ 0x2789, 0x05c9 }, // 201, 5
|
|
{ 0x278A, 0x05ca }, // 202, 5
|
|
{ 0x278B, 0x05cb }, // 203, 5
|
|
{ 0x278C, 0x05cc }, // 204, 5
|
|
{ 0x278D, 0x05cd }, // 205, 5
|
|
{ 0x278E, 0x05ce }, // 206, 5
|
|
{ 0x278F, 0x05cf }, // 207, 5
|
|
{ 0x2790, 0x05d0 }, // 208, 5
|
|
{ 0x2791, 0x05d1 }, // 209, 5
|
|
{ 0x2792, 0x05d2 }, // 210, 5
|
|
{ 0x2793, 0x05d3 }, // 211, 5
|
|
{ 0x2794, 0x05d4 }, // 212, 5
|
|
{ 0x2798, 0x05d8 }, // 216, 5
|
|
{ 0x2799, 0x05d9 }, // 217, 5
|
|
{ 0x279A, 0x05da }, // 218, 5
|
|
{ 0x279B, 0x05db }, // 219, 5
|
|
{ 0x279C, 0x05dc }, // 220, 5
|
|
{ 0x279D, 0x05dd }, // 221, 5
|
|
{ 0x279E, 0x05de }, // 222, 5
|
|
{ 0x279F, 0x05df }, // 223, 5
|
|
{ 0x27A0, 0x05e0 }, // 224, 5
|
|
{ 0x27A1, 0x05e1 }, // 225, 5
|
|
{ 0x27A2, 0x05e2 }, // 226, 5
|
|
{ 0x27A3, 0x05e3 }, // 227, 5
|
|
{ 0x27A4, 0x05e4 }, // 228, 5
|
|
{ 0x27A5, 0x05e5 }, // 229, 5
|
|
{ 0x27A6, 0x05e6 }, // 230, 5
|
|
{ 0x27A7, 0x05e7 }, // 231, 5
|
|
{ 0x27A8, 0x05e8 }, // 232, 5
|
|
{ 0x27A9, 0x05e9 }, // 233, 5
|
|
{ 0x27AA, 0x05ea }, // 234, 5
|
|
{ 0x27AB, 0x05eb }, // 235, 5
|
|
{ 0x27AC, 0x05ec }, // 236, 5
|
|
{ 0x27AD, 0x05ed }, // 237, 5
|
|
{ 0x27AE, 0x05ee }, // 238, 5
|
|
{ 0x27AF, 0x05ef }, // 239, 5
|
|
{ 0x27B1, 0x05f1 }, // 241, 5
|
|
{ 0x27B2, 0x05f2 }, // 242, 5
|
|
{ 0x27B3, 0x05f3 }, // 243, 5
|
|
{ 0x27B4, 0x05f4 }, // 244, 5
|
|
{ 0x27B5, 0x05f5 }, // 245, 5
|
|
{ 0x27B6, 0x05f6 }, // 246, 5
|
|
{ 0x27B7, 0x05f7 }, // 247, 5
|
|
{ 0x27B8, 0x05f8 }, // 248, 5
|
|
{ 0x27B9, 0x05f9 }, // 249, 5
|
|
{ 0x27BA, 0x05fa }, // 250, 5
|
|
{ 0x27BB, 0x05fb }, // 251, 5
|
|
{ 0x27BC, 0x05fc }, // 252, 5
|
|
{ 0x27BD, 0x05fd }, // 253, 5
|
|
{ 0x27BE, 0x05fe }, // 254, 5
|
|
|
|
// Range 0xE000 through 0xF8FF is reserved for private use.
|
|
// We cannot try to interpret characters in this range nor
|
|
// assign any default collation or meaning.
|
|
|
|
{ 0xFB00, 0x0433 }, // 51 , 4
|
|
{ 0xFB01, 0x0436 }, // 54 , 4
|
|
{ 0xFB02, 0x0437 }, // 55 , 4
|
|
{ 0xFB03, 0x0434 }, // 52 , 4
|
|
{ 0xFB04, 0x0435 }, // 53 , 4
|
|
{ 0xFB1E, 0x0930 }, // 48 , 9
|
|
{ 0xFF61, 0x0b00 }, // 0 , 11
|
|
{ 0xFF62, 0x0b01 }, // 1 , 11
|
|
{ 0xFF63, 0x0b02 }, // 2 , 11
|
|
{ 0xFF64, 0x0b03 }, // 3 , 11
|
|
{ 0xFF65, 0x0b04 }, // 4 , 11
|
|
{ 0xFF66, 0x0b05 }, // 5 , 11
|
|
{ 0xFF67, 0x0b06 }, // 6 , 11
|
|
{ 0xFF68, 0x0b07 }, // 7 , 11
|
|
{ 0xFF69, 0x0b08 }, // 8 , 11
|
|
{ 0xFF6A, 0x0b09 }, // 9 , 11
|
|
{ 0xFF6B, 0x0b0a }, // 10 , 11
|
|
{ 0xFF6C, 0x0b0b }, // 11 , 11
|
|
{ 0xFF6D, 0x0b0c }, // 12 , 11
|
|
{ 0xFF6E, 0x0b0d }, // 13 , 11
|
|
{ 0xFF6F, 0x0b0e }, // 14 , 11
|
|
{ 0xFF70, 0x0b0f }, // 15 , 11
|
|
{ 0xFF71, 0x0b10 }, // 16 , 11
|
|
{ 0xFF72, 0x0b11 }, // 17 , 11
|
|
{ 0xFF73, 0x0b12 }, // 18 , 11
|
|
{ 0xFF74, 0x0b13 }, // 19 , 11
|
|
{ 0xFF75, 0x0b14 }, // 20 , 11
|
|
{ 0xFF76, 0x0b15 }, // 21 , 11
|
|
{ 0xFF77, 0x0b16 }, // 22 , 11
|
|
{ 0xFF78, 0x0b17 }, // 23 , 11
|
|
{ 0xFF79, 0x0b18 }, // 24 , 11
|
|
{ 0xFF7A, 0x0b19 }, // 25 , 11
|
|
{ 0xFF7B, 0x0b1a }, // 26 , 11
|
|
{ 0xFF7C, 0x0b1b }, // 27 , 11
|
|
{ 0xFF7D, 0x0b1c }, // 28 , 11
|
|
{ 0xFF7E, 0x0b1d }, // 29 , 11
|
|
{ 0xFF7F, 0x0b1e }, // 30 , 11
|
|
{ 0xFF80, 0x0b1f }, // 31 , 11
|
|
{ 0xFF81, 0x0b20 }, // 32 , 11
|
|
{ 0xFF82, 0x0b21 }, // 33 , 11
|
|
{ 0xFF83, 0x0b22 }, // 34 , 11
|
|
{ 0xFF84, 0x0b23 }, // 35 , 11
|
|
{ 0xFF85, 0x0b24 }, // 36 , 11
|
|
{ 0xFF86, 0x0b25 }, // 37 , 11
|
|
{ 0xFF87, 0x0b26 }, // 38 , 11
|
|
{ 0xFF88, 0x0b27 }, // 39 , 11
|
|
{ 0xFF89, 0x0b28 }, // 40 , 11
|
|
{ 0xFF8A, 0x0b29 }, // 41 , 11
|
|
{ 0xFF8B, 0x0b2a }, // 42 , 11
|
|
{ 0xFF8C, 0x0b2b }, // 43 , 11
|
|
{ 0xFF8D, 0x0b2c }, // 44 , 11
|
|
{ 0xFF8E, 0x0b2d }, // 45 , 11
|
|
{ 0xFF8F, 0x0b2e }, // 46 , 11
|
|
{ 0xFF90, 0x0b2f }, // 47 , 11
|
|
{ 0xFF91, 0x0b30 }, // 48 , 11
|
|
{ 0xFF92, 0x0b31 }, // 49 , 11
|
|
{ 0xFF93, 0x0b32 }, // 50 , 11
|
|
{ 0xFF94, 0x0b33 }, // 51 , 11
|
|
{ 0xFF95, 0x0b34 }, // 52 , 11
|
|
{ 0xFF96, 0x0b35 }, // 53 , 11
|
|
{ 0xFF97, 0x0b36 }, // 54 , 11
|
|
{ 0xFF98, 0x0b37 }, // 55 , 11
|
|
{ 0xFF99, 0x0b38 }, // 56 , 11
|
|
{ 0xFF9A, 0x0b39 }, // 57 , 11
|
|
{ 0xFF9B, 0x0b3a }, // 58 , 11
|
|
{ 0xFF9C, 0x0b3b }, // 59 , 11
|
|
{ 0xFF9D, 0x0b3c }, // 60 , 11
|
|
{ 0xFF9E, 0x0b3d }, // 61 , 11
|
|
{ 0xFF9F, 0x0b3e } // 62 , 11
|
|
};
|
|
|
|
/****************************************************************************
|
|
Desc: Encode a string into FLAIM's internal text format
|
|
(SEN-prefixed, null-terminated UTF8). The string is prefixed with
|
|
a SEN that indicates the number of characters, not including the
|
|
terminating NULL.
|
|
|
|
This routine can be called with a NULL input buffer. If it is
|
|
called in this way, the length of the encoded string will be
|
|
returned in *puiBufLength, but no encoding will actually be
|
|
performed.
|
|
****************************************************************************/
|
|
RCODE flmUnicode2Storage(
|
|
const FLMUNICODE * puzStr, // UNICODE string to encode
|
|
FLMUINT uiStrLen, // 0 = Unknown
|
|
FLMBYTE * pucBuf, // Destination buffer
|
|
FLMUINT * puiBufLength, // [IN ] Size of pucBuf,
|
|
// [OUT] Amount of pucBuf used
|
|
FLMUINT * puiCharCount)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
FLMBYTE * pucEncPtr;
|
|
const FLMUNICODE * puzPtr = NULL;
|
|
FLMUINT uiMaxLen;
|
|
FLMUINT uiCharsEncoded = 0;
|
|
FLMUINT uiEncodedLen = 0;
|
|
FLMUINT uiTmp;
|
|
FLMUNICODE uChar;
|
|
FLMBYTE ucTmpSen[ 5];
|
|
FLMBYTE * pucTmpSen = &ucTmpSen[ 0];
|
|
|
|
if( !pucBuf)
|
|
{
|
|
uiMaxLen = (~(FLMUINT)0);
|
|
}
|
|
else
|
|
{
|
|
uiMaxLen = *puiBufLength;
|
|
}
|
|
|
|
// If uiStrLen is 0, determine the number of characters.
|
|
|
|
if( !uiStrLen)
|
|
{
|
|
uiStrLen = f_unilen( puzStr);
|
|
}
|
|
else if( puzStr[ uiStrLen] != 0)
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_INVALID_PARM);
|
|
goto Exit;
|
|
}
|
|
|
|
if( puiCharCount)
|
|
{
|
|
*puiCharCount = uiStrLen;
|
|
}
|
|
|
|
if( !uiStrLen)
|
|
{
|
|
// Nothing to encode
|
|
|
|
*puiBufLength = 0;
|
|
goto Exit;
|
|
}
|
|
|
|
pucEncPtr = pucBuf;
|
|
|
|
// Encode the number of characters as a SEN. If pucEncPtr is
|
|
// NULL, the caller is only interested in the length of the encoded
|
|
// string, so a temporary buffer is used to call flmEncodeSEN.
|
|
|
|
uiTmp = flmEncodeSEN( uiStrLen, &pucTmpSen);
|
|
|
|
if( pucEncPtr)
|
|
{
|
|
if( (uiEncodedLen + uiTmp) >= uiMaxLen)
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
|
|
goto Exit;
|
|
}
|
|
|
|
if( uiTmp == 1)
|
|
{
|
|
*pucEncPtr++ = ucTmpSen[ 0];
|
|
}
|
|
else
|
|
{
|
|
f_memcpy( pucEncPtr, &ucTmpSen[ 0], uiTmp);
|
|
pucEncPtr += uiTmp;
|
|
}
|
|
}
|
|
uiEncodedLen += uiTmp;
|
|
|
|
// Encode the string using UTF-8
|
|
|
|
puzPtr = puzStr;
|
|
if( uiStrLen)
|
|
{
|
|
while( (uChar = *puzPtr) != 0)
|
|
{
|
|
if( (uiTmp = uiMaxLen - uiEncodedLen) == 0)
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
|
|
goto Exit;
|
|
}
|
|
|
|
if( uChar <= 127)
|
|
{
|
|
if( pucEncPtr)
|
|
{
|
|
*pucEncPtr++ = (FLMBYTE)uChar;
|
|
}
|
|
|
|
uiEncodedLen++;
|
|
}
|
|
else
|
|
{
|
|
if( RC_BAD( rc = flmUni2UTF8( uChar, pucEncPtr, &uiTmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( pucEncPtr)
|
|
{
|
|
pucEncPtr += uiTmp;
|
|
}
|
|
|
|
uiEncodedLen += uiTmp;
|
|
}
|
|
|
|
puzPtr++;
|
|
uiCharsEncoded++;
|
|
}
|
|
|
|
// Make sure the string length (which may have been provided by
|
|
// the caller) was correct.
|
|
|
|
if( uiCharsEncoded != uiStrLen)
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_INVALID_PARM);
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
// Terminate the string with a 0 byte
|
|
|
|
if( (uiMaxLen - uiEncodedLen) < 1)
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
|
|
goto Exit;
|
|
}
|
|
|
|
if( pucEncPtr)
|
|
{
|
|
*pucEncPtr++ = 0;
|
|
}
|
|
uiEncodedLen++;
|
|
|
|
// Return the length of the encoded string
|
|
|
|
*puiBufLength = uiEncodedLen;
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/****************************************************************************
|
|
Desc: Encode a string into FLAIM's internal text format
|
|
(SEN-prefixed, null-terminated UTF8). The string is prefixed with
|
|
a SEN that indicates the number of characters, not including the
|
|
terminating NULL.
|
|
|
|
This routine can be called with a NULL input buffer. If it is
|
|
called in this way, the length of the encoded string will be
|
|
returned in *puiBufLength, but no encoding will actually be
|
|
performed.
|
|
****************************************************************************/
|
|
RCODE flmNative2Storage(
|
|
char * pszStr, // Native string to encode
|
|
FLMUINT uiStrLen, // 0 = Unknown
|
|
FLMBYTE * pucBuf, // Destination buffer
|
|
FLMUINT * puiBufLength, // [IN ] Size of pucBuf,
|
|
// [OUT] Amount of pucBuf used
|
|
FLMUINT * puiCharCount)
|
|
{
|
|
FLMBYTE * pucEncPtr;
|
|
char * pszPtr = NULL;
|
|
FLMUINT uiMaxLen;
|
|
FLMUINT uiCharsEncoded = 0;
|
|
FLMUINT uiEncodedLen = 0;
|
|
FLMUINT uiTmp;
|
|
FLMBYTE ucTmpSen[ 5];
|
|
FLMBYTE * pucTmpSen = &ucTmpSen[ 0];
|
|
FLMBOOL bDirectCopy = FALSE;
|
|
RCODE rc = NE_XFLM_OK;
|
|
|
|
if( !pucBuf)
|
|
{
|
|
uiMaxLen = (~(FLMUINT)0);
|
|
}
|
|
else
|
|
{
|
|
uiMaxLen = *puiBufLength;
|
|
}
|
|
|
|
// If uiStrLen is 0, determine the number of characters.
|
|
|
|
if( !uiStrLen)
|
|
{
|
|
#ifdef FLM_ASCII_PLATFORM
|
|
bDirectCopy = TRUE;
|
|
for( pszPtr = pszStr; *pszPtr; pszPtr++, uiStrLen++)
|
|
{
|
|
if( (FLMBYTE)*pszPtr > 0x7F)
|
|
{
|
|
bDirectCopy = FALSE;
|
|
}
|
|
}
|
|
#else
|
|
uiStrLen = f_strlen( pszStr);
|
|
#endif
|
|
}
|
|
else if( pszStr[ uiStrLen] != 0)
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_INVALID_PARM);
|
|
goto Exit;
|
|
}
|
|
|
|
if( puiCharCount)
|
|
{
|
|
*puiCharCount = uiStrLen;
|
|
}
|
|
|
|
if( !uiStrLen)
|
|
{
|
|
// Nothing to encode
|
|
|
|
*puiBufLength = 0;
|
|
goto Exit;
|
|
}
|
|
|
|
pucEncPtr = pucBuf;
|
|
|
|
// Encode the number of characters as a SEN. If pucEncPtr is
|
|
// NULL, the caller is only interested in the length of the encoded
|
|
// string, so a temporary buffer is used to call flmEncodeSEN.
|
|
|
|
uiTmp = flmEncodeSEN( uiStrLen, &pucTmpSen);
|
|
if( pucEncPtr)
|
|
{
|
|
if( (uiEncodedLen + uiTmp) >= uiMaxLen)
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
|
|
goto Exit;
|
|
}
|
|
f_memcpy( pucEncPtr, &ucTmpSen[ 0], uiTmp);
|
|
pucEncPtr += uiTmp;
|
|
}
|
|
uiEncodedLen += uiTmp;
|
|
|
|
// Encode the string using UTF-8
|
|
|
|
if( uiStrLen)
|
|
{
|
|
if( bDirectCopy)
|
|
{
|
|
// Since all of the characters are ASCII and have
|
|
// values <= 0x7F, the string can be copied directly
|
|
// into the destination buffer buffer.
|
|
|
|
if( uiEncodedLen + uiStrLen >= uiMaxLen)
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
|
|
goto Exit;
|
|
}
|
|
|
|
if( pucEncPtr)
|
|
{
|
|
f_memcpy( pucEncPtr, pszStr, uiStrLen);
|
|
pucEncPtr += uiStrLen;
|
|
}
|
|
uiEncodedLen += uiStrLen;
|
|
}
|
|
else
|
|
{
|
|
pszPtr = pszStr;
|
|
while( *pszPtr)
|
|
{
|
|
if( (uiTmp = uiMaxLen - uiEncodedLen) == 0)
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
|
|
goto Exit;
|
|
}
|
|
|
|
// Convert the native character to ASCII before
|
|
// mapping it to Unicode.
|
|
|
|
if( RC_BAD( rc = flmUni2UTF8( (FLMUNICODE)f_toascii( *pszPtr),
|
|
pucEncPtr, &uiTmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
uiEncodedLen += uiTmp;
|
|
|
|
if( pucEncPtr)
|
|
{
|
|
pucEncPtr += uiTmp;
|
|
}
|
|
|
|
pszPtr++;
|
|
uiCharsEncoded++;
|
|
}
|
|
|
|
// Make sure the string length (which may have been provided by
|
|
// the caller) was correct.
|
|
|
|
if( uiCharsEncoded != uiStrLen)
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_INVALID_PARM);
|
|
goto Exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Terminate the string with a 0 byte
|
|
|
|
if( (uiMaxLen - uiEncodedLen) == 0)
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
|
|
goto Exit;
|
|
}
|
|
|
|
if( pucEncPtr)
|
|
{
|
|
*pucEncPtr++ = 0;
|
|
}
|
|
uiEncodedLen++;
|
|
|
|
// Return the length of the encoded string
|
|
|
|
*puiBufLength = uiEncodedLen;
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/****************************************************************************
|
|
Desc: Encode a string into FLAIM's internal text format
|
|
(SEN-prefixed, null-terminated UTF8). The string is prefixed with
|
|
a SEN that indicates the number of characters, not including the
|
|
terminating NULL.
|
|
|
|
This routine can be called with a NULL input buffer. If it is
|
|
called in this way, the length of the encoded string will be
|
|
returned in *puiBufLength, but no encoding will actually be
|
|
performed.
|
|
****************************************************************************/
|
|
RCODE flmUTF8ToStorage(
|
|
const FLMBYTE * pucUTF8, // UTF8 string to encode
|
|
FLMUINT uiBytesInBuffer, // Maximum bytes to process from source
|
|
FLMBYTE * pucBuf, // Destination buffer
|
|
FLMUINT * puiBufLength) // [IN ] Size of pucBuf,
|
|
// [OUT] Amount of pucBuf used
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
FLMBYTE * pucEncPtr;
|
|
const FLMBYTE * pucPtr = NULL;
|
|
FLMUINT uiMaxLen;
|
|
FLMUINT uiEncodedLen = 0;
|
|
FLMUINT uiCharCount;
|
|
FLMUINT uiByteCount;
|
|
FLMUINT uiTmp;
|
|
FLMUNICODE uChar;
|
|
FLMBYTE ucTmpSen[ 5];
|
|
FLMBYTE * pucTmpSen = &ucTmpSen[ 0];
|
|
const FLMBYTE * pucEnd = NULL;
|
|
|
|
if( !pucBuf)
|
|
{
|
|
uiMaxLen = (~(FLMUINT)0);
|
|
}
|
|
else
|
|
{
|
|
uiMaxLen = *puiBufLength;
|
|
}
|
|
|
|
if( uiBytesInBuffer)
|
|
{
|
|
pucEnd = &pucUTF8[ uiBytesInBuffer];
|
|
}
|
|
|
|
// Determine the number of bytes and characters in the
|
|
// string
|
|
|
|
uiCharCount = 0;
|
|
pucPtr = pucUTF8;
|
|
for( ;;)
|
|
{
|
|
if( RC_BAD( rc = flmGetCharFromUTF8Buf( &pucPtr, pucEnd, &uChar)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( !uChar)
|
|
{
|
|
break;
|
|
}
|
|
|
|
uiCharCount++;
|
|
}
|
|
|
|
if( !uiCharCount)
|
|
{
|
|
*puiBufLength = 0;
|
|
goto Exit;
|
|
}
|
|
|
|
pucEncPtr = pucBuf;
|
|
|
|
// Encode the number of characters as a SEN. If pucEncPtr is
|
|
// NULL, the caller is only interested in the length of the encoded
|
|
// string, so a temporary buffer is used to call flmEncodeSEN.
|
|
|
|
uiTmp = flmEncodeSEN( uiCharCount, &pucTmpSen);
|
|
if( pucEncPtr)
|
|
{
|
|
if( (uiEncodedLen + uiTmp) >= uiMaxLen)
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
|
|
goto Exit;
|
|
}
|
|
f_memcpy( pucEncPtr, &ucTmpSen[ 0], uiTmp);
|
|
pucEncPtr += uiTmp;
|
|
}
|
|
uiEncodedLen += uiTmp;
|
|
|
|
// Copy the UTF8 characters into the destination buffer
|
|
|
|
uiByteCount = (FLMUINT)(pucPtr - pucUTF8);
|
|
if( pucEncPtr)
|
|
{
|
|
if( (uiMaxLen - uiEncodedLen) < uiByteCount)
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
|
|
goto Exit;
|
|
}
|
|
f_memcpy( pucEncPtr, pucUTF8, uiByteCount);
|
|
pucEncPtr += uiByteCount;
|
|
}
|
|
uiEncodedLen += uiByteCount;
|
|
|
|
// Terminate the string with a 0 byte
|
|
|
|
if( uiEncodedLen == uiMaxLen)
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
|
|
goto Exit;
|
|
}
|
|
|
|
if( pucEncPtr)
|
|
{
|
|
*pucEncPtr++ = 0;
|
|
}
|
|
uiEncodedLen++;
|
|
|
|
// Return the length of the encoded string
|
|
|
|
*puiBufLength = uiEncodedLen;
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/****************************************************************************
|
|
Desc: Convert text storage string to Unicode.
|
|
Notes: If puzOutBuf is NULL, only a count is returned
|
|
in puiOutBufLen to indicate the number of bytes needed to
|
|
contain the data. Two (unicode) bytes must be
|
|
added to this value to account for null termination.
|
|
****************************************************************************/
|
|
RCODE flmStorage2Unicode(
|
|
FLMUINT uiType,
|
|
FLMUINT uiBufLength,
|
|
const FLMBYTE * pucBuffer,
|
|
FLMUINT * puiOutBufLen,
|
|
// [IN] Number of bytes available in buffer
|
|
// [OUT] Returns the number of bytes that are needed to
|
|
// represent the data. The null termination byte(s) are
|
|
// not included in this value.
|
|
void * pOutBuf)
|
|
// [IN/OUT] Buffer to hold the data.
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
FLMUNICODE uChar;
|
|
FLMUINT uiOffset = 0;
|
|
FLMUINT uiSenLen;
|
|
FLMUINT uiNumChars;
|
|
FLMUINT uiMaxOutChars;
|
|
FLMBYTE ucTempBuf[ 64];
|
|
FLMUNICODE * puzOutBuf = NULL;
|
|
FLMBYTE * pszOutBuf = NULL;
|
|
const FLMBYTE * pucEnd;
|
|
FLMUINT uiDecodeCount;
|
|
|
|
if( !pucBuffer || !uiBufLength)
|
|
{
|
|
ucTempBuf[ 0] = 0; // SEN encoding of 0
|
|
ucTempBuf[ 1] = 0; // String terminator
|
|
pucBuffer = &ucTempBuf[ 0];
|
|
uiBufLength = 2;
|
|
}
|
|
else if( uiType != XFLM_TEXT_TYPE)
|
|
{
|
|
// If the value is a number, convert to text
|
|
|
|
if( uiType == XFLM_NUMBER_TYPE)
|
|
{
|
|
FLMUINT uiTmp;
|
|
|
|
uiTmp = sizeof( ucTempBuf);
|
|
if( RC_BAD( rc = flmStorageNum2StorageText( pucBuffer, uiBufLength,
|
|
ucTempBuf, &uiTmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
pucBuffer = &ucTempBuf[ 0];
|
|
uiBufLength = uiTmp;
|
|
}
|
|
else
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_ILLEGAL);
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
if( !uiBufLength)
|
|
{
|
|
if( puiOutBufLen)
|
|
{
|
|
if( *puiOutBufLen >= 2)
|
|
{
|
|
*((FLMUNICODE *)pOutBuf) = 0;
|
|
}
|
|
|
|
*puiOutBufLen = 0;
|
|
}
|
|
goto Exit;
|
|
}
|
|
|
|
pucEnd = &pucBuffer[ uiBufLength];
|
|
|
|
uiSenLen = flmGetSENLength( *pucBuffer);
|
|
if( pucBuffer + uiSenLen >= pucEnd)
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_DATA_ERROR);
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = flmDecodeSEN( &pucBuffer, pucEnd, &uiNumChars)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
// If only a length is needed (number of bytes), we can
|
|
// return that without parsing the string
|
|
|
|
if( !pOutBuf)
|
|
{
|
|
uiOffset = uiNumChars;
|
|
goto Exit;
|
|
}
|
|
|
|
flmAssert( puiOutBufLen);
|
|
uiMaxOutChars = (*puiOutBufLen) / sizeof( FLMUNICODE);
|
|
puzOutBuf = (FLMUNICODE *)pOutBuf;
|
|
|
|
// If we have a zero-length string, jump to exit.
|
|
|
|
if( !uiNumChars)
|
|
{
|
|
if( (pucBuffer + 1) != pucEnd || *pucBuffer != 0)
|
|
{
|
|
rc = RC_SET( NE_XFLM_DATA_ERROR);
|
|
goto Exit;
|
|
}
|
|
|
|
if( *pucBuffer != 0)
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_DATA_ERROR);
|
|
}
|
|
else if (!uiMaxOutChars)
|
|
{
|
|
goto Overflow_Error;
|
|
}
|
|
|
|
if( puzOutBuf)
|
|
{
|
|
*puzOutBuf = 0;
|
|
}
|
|
else
|
|
{
|
|
*pszOutBuf = 0;
|
|
}
|
|
|
|
goto Exit;
|
|
}
|
|
|
|
// Parse through the string, outputting data to the buffer as we go.
|
|
|
|
uChar = 0;
|
|
uiDecodeCount = 0;
|
|
for( ;;)
|
|
{
|
|
// Decode the bytes.
|
|
|
|
if( RC_BAD( rc = flmGetCharFromUTF8Buf( &pucBuffer, pucEnd, &uChar)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( !uChar)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if( uiOffset == uiMaxOutChars)
|
|
{
|
|
goto Overflow_Error;
|
|
}
|
|
|
|
if( puzOutBuf)
|
|
{
|
|
puzOutBuf[ uiOffset++] = uChar;
|
|
}
|
|
else
|
|
{
|
|
if ( uChar <= 0xFF)
|
|
{
|
|
uChar = (FLMUNICODE)f_tonative( (FLMBYTE)uChar);
|
|
pszOutBuf[ uiOffset++] = (FLMBYTE)uChar;
|
|
}
|
|
else
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_ILLEGAL);
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
uiDecodeCount++;
|
|
}
|
|
|
|
if( uChar || uiDecodeCount != uiNumChars)
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_DATA_ERROR);
|
|
goto Exit;
|
|
}
|
|
|
|
// There is room for the 0 terminating character, but we
|
|
// will not increment return length.
|
|
|
|
if( uiOffset < uiMaxOutChars)
|
|
{
|
|
if( puzOutBuf)
|
|
{
|
|
puzOutBuf[ uiOffset] = 0;
|
|
}
|
|
else
|
|
{
|
|
pszOutBuf[ uiOffset] = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Overflow_Error:
|
|
flmAssert( uiOffset == uiMaxOutChars);
|
|
|
|
// If uiOffset is zero, so is uiMaxOutChars, which means
|
|
// that we can't even put out the zero terminator.
|
|
|
|
if (uiOffset)
|
|
{
|
|
uiOffset--;
|
|
if( puzOutBuf)
|
|
{
|
|
puzOutBuf[ uiOffset] = 0;
|
|
}
|
|
else
|
|
{
|
|
pszOutBuf[ uiOffset] = 0;
|
|
}
|
|
}
|
|
rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
|
|
goto Exit;
|
|
}
|
|
|
|
Exit:
|
|
|
|
if( puiOutBufLen)
|
|
{
|
|
*puiOutBufLen = uiOffset + uiOffset;
|
|
}
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/****************************************************************************
|
|
Desc: Converts storage formats to UNICODE
|
|
****************************************************************************/
|
|
RCODE flmStorage2Unicode(
|
|
FLMUINT uiType,
|
|
FLMUINT uiStorageLength,
|
|
const FLMBYTE * pucStorageBuffer,
|
|
IF_DynaBuf * pBuffer)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
FLMBYTE ucTempBuf[ 80];
|
|
const FLMBYTE * pucEnd;
|
|
FLMUINT uiSenLen;
|
|
FLMUINT uiNumChars;
|
|
FLMUNICODE * puzDestBuffer;
|
|
|
|
pBuffer->truncateData( 0);
|
|
|
|
if( uiType != XFLM_TEXT_TYPE)
|
|
{
|
|
// If the value is a number, convert to text
|
|
|
|
if( uiType == XFLM_NUMBER_TYPE)
|
|
{
|
|
FLMUINT uiTmp;
|
|
|
|
uiStorageLength = sizeof( ucTempBuf);
|
|
if( RC_BAD( rc = flmStorageNum2StorageText( pucStorageBuffer,
|
|
uiStorageLength, ucTempBuf, &uiTmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
pucStorageBuffer = &ucTempBuf[ 0];
|
|
uiStorageLength = uiTmp;
|
|
}
|
|
else
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_ILLEGAL);
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
pucEnd = &pucStorageBuffer[ uiStorageLength];
|
|
uiSenLen = flmGetSENLength( *pucStorageBuffer);
|
|
|
|
if( pucStorageBuffer + uiSenLen >= pucEnd)
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_DATA_ERROR);
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = flmDecodeSEN( &pucStorageBuffer, pucEnd, &uiNumChars)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = pBuffer->allocSpace(
|
|
(uiNumChars + 1) * sizeof( FLMUNICODE), (void **)&puzDestBuffer)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
// Parse through the string outputting data to the buffer as we go
|
|
|
|
for( ;;)
|
|
{
|
|
if( RC_BAD( rc = flmGetCharFromUTF8Buf(
|
|
&pucStorageBuffer, pucEnd, puzDestBuffer)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( !(*puzDestBuffer))
|
|
{
|
|
break;
|
|
}
|
|
|
|
puzDestBuffer++;
|
|
}
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/****************************************************************************
|
|
Desc: Converts a storage buffer to UTF-8 (null-terminated) text
|
|
****************************************************************************/
|
|
RCODE flmStorage2UTF8(
|
|
FLMUINT uiType,
|
|
FLMUINT uiBufLength,
|
|
const FLMBYTE * pucBuffer,
|
|
FLMUINT * puiOutBufLen,
|
|
// [IN] Number of bytes available in buffer
|
|
// [OUT] Returns the number of bytes that are needed to
|
|
// represent the data. The null termination byte is not
|
|
// included in this value.
|
|
FLMBYTE * pucOutBuf)
|
|
// [OUT] Buffer to hold the data.
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
const FLMBYTE * pucEnd;
|
|
FLMBYTE ucTempBuf[ 64];
|
|
FLMUINT uiSenLen;
|
|
|
|
if( !pucBuffer)
|
|
{
|
|
ucTempBuf[ 0] = 0; // SEN encoding of 0
|
|
ucTempBuf[ 1] = 0; // String terminator
|
|
pucBuffer = &ucTempBuf[ 0];
|
|
uiBufLength = 2;
|
|
}
|
|
else if( uiType != XFLM_TEXT_TYPE)
|
|
{
|
|
// If the value is a number, convert to text
|
|
|
|
if( uiType == XFLM_NUMBER_TYPE)
|
|
{
|
|
FLMUINT uiTmp;
|
|
|
|
uiTmp = sizeof( ucTempBuf);
|
|
if( RC_BAD( rc = flmStorageNum2StorageText( pucBuffer, uiBufLength,
|
|
ucTempBuf, &uiTmp)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
pucBuffer = &ucTempBuf[ 0];
|
|
uiBufLength = uiTmp;
|
|
}
|
|
else
|
|
{
|
|
rc = RC_SET( NE_XFLM_CONV_ILLEGAL);
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
if( !uiBufLength)
|
|
{
|
|
if( *puiOutBufLen && pucOutBuf)
|
|
{
|
|
*pucOutBuf = 0;
|
|
}
|
|
*puiOutBufLen = 0;
|
|
goto Exit;
|
|
}
|
|
|
|
pucEnd = &pucBuffer[ uiBufLength];
|
|
|
|
uiSenLen = flmGetSENLength( *pucBuffer);
|
|
if( pucBuffer + uiSenLen >= pucEnd)
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_DATA_ERROR);
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = flmDecodeSEN( &pucBuffer, pucEnd, NULL)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( pucOutBuf)
|
|
{
|
|
if( *puiOutBufLen >= uiBufLength - uiSenLen)
|
|
{
|
|
f_memcpy( pucOutBuf, pucBuffer, uiBufLength - uiSenLen);
|
|
}
|
|
}
|
|
|
|
*puiOutBufLen = (uiBufLength - uiSenLen) - 1;
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/****************************************************************************
|
|
Desc: Reads and returns the value of the SEN indicating the number of
|
|
characters encoded into the storage (UTF-8) string
|
|
****************************************************************************/
|
|
RCODE flmGetCharCountFromStorageBuf(
|
|
const FLMBYTE ** ppucBuf,
|
|
FLMUINT uiBufSize,
|
|
FLMUINT * puiNumChars,
|
|
FLMUINT * puiSenLen)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
FLMUINT uiSenLen;
|
|
FLMUINT uiNumChars;
|
|
|
|
if( !uiBufSize)
|
|
{
|
|
if( puiNumChars)
|
|
{
|
|
*puiNumChars = 0;
|
|
}
|
|
|
|
if( puiSenLen)
|
|
{
|
|
*puiSenLen = 0;
|
|
}
|
|
goto Exit;
|
|
}
|
|
|
|
if( (uiSenLen = flmGetSENLength( (*ppucBuf)[ 0])) >= uiBufSize)
|
|
{
|
|
rc = RC_SET( NE_XFLM_DATA_ERROR);
|
|
goto Exit;
|
|
}
|
|
|
|
if( RC_BAD( rc = flmDecodeSEN( ppucBuf, *ppucBuf + uiSenLen, &uiNumChars)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if( puiNumChars)
|
|
{
|
|
*puiNumChars = uiNumChars;
|
|
}
|
|
|
|
if( puiSenLen)
|
|
{
|
|
*puiSenLen = uiSenLen;
|
|
}
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/****************************************************************************
|
|
Desc: This routine converts an internal number to internal (ASCII) text.
|
|
Notes: If the buffer pointer is NULL, the routine just determines how
|
|
much buffer space is needed to store the number in a text string.
|
|
****************************************************************************/
|
|
RCODE flmStorageNum2StorageText(
|
|
const FLMBYTE * pucNum,
|
|
FLMUINT uiNumLen,
|
|
FLMBYTE * pucBuffer,
|
|
FLMUINT * puiBufLen)
|
|
{
|
|
RCODE rc = NE_XFLM_OK;
|
|
FLMUINT64 ui64Num;
|
|
FLMINT64 i64Num;
|
|
FLMUINT uiOffset = 0;
|
|
FLMBOOL bNeg = FALSE;
|
|
char szTmpBuf[ 64];
|
|
|
|
if( RC_BAD( rc = flmStorage2Number64( XFLM_NUMBER_TYPE, uiNumLen,
|
|
pucNum, &ui64Num, NULL)))
|
|
{
|
|
if( rc == NE_XFLM_CONV_NUM_UNDERFLOW)
|
|
{
|
|
if( RC_BAD( rc = flmStorage2Number64( XFLM_NUMBER_TYPE, uiNumLen,
|
|
pucNum, NULL, &i64Num)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
ui64Num = (FLMUINT64)-i64Num;
|
|
bNeg = TRUE;
|
|
}
|
|
else
|
|
{
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
if( bNeg)
|
|
{
|
|
szTmpBuf[ uiOffset++] = '-';
|
|
}
|
|
|
|
uiOffset += f_sprintf( &szTmpBuf[ uiOffset], "%I64u", ui64Num);
|
|
|
|
if( RC_BAD( rc = flmNative2Storage( szTmpBuf, uiOffset,
|
|
pucBuffer, puiBufLen, NULL)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
Exit:
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/****************************************************************************
|
|
Desc: Called by FlmStartup, this routine initializes the Unicode to
|
|
WP and WP to Unicode mapping tables.
|
|
****************************************************************************/
|
|
RCODE F_DbSystem::initCharMappingTables( void)
|
|
{
|
|
FLMUINT16 * puStaticPtr;
|
|
FLMUINT uiLoop;
|
|
FLMUINT uiEntries;
|
|
FLMUINT uiOffset;
|
|
RCODE rc = NE_XFLM_OK;
|
|
|
|
if( gv_pUnicodeToWP60 || gv_pWP60ToUnicode)
|
|
{
|
|
rc = RC_SET_AND_ASSERT( NE_XFLM_FAILURE);
|
|
goto Exit;
|
|
}
|
|
|
|
gv_uiMinUniChar = 0;
|
|
gv_uiMaxUniChar = 0;
|
|
|
|
gv_uiMinWPChar = 0;
|
|
gv_uiMaxWPChar = 0;
|
|
|
|
// Make an initial pass over the table to determine
|
|
// what our allocation sizes will need to be.
|
|
|
|
for( uiLoop = 0, puStaticPtr = (FLMUINT16 *)WP_UTOWP60;
|
|
uiLoop < UTOWP60_ENTRIES;
|
|
uiLoop++, puStaticPtr += 2)
|
|
{
|
|
// Unicode
|
|
|
|
if( (FLMUINT)puStaticPtr[ 0] < gv_uiMinUniChar ||
|
|
!gv_uiMinUniChar)
|
|
{
|
|
flmAssert( puStaticPtr[ 0] != 0);
|
|
gv_uiMinUniChar = (FLMUINT)puStaticPtr[ 0];
|
|
}
|
|
|
|
if( (FLMUINT)puStaticPtr[ 0] > gv_uiMaxUniChar)
|
|
{
|
|
gv_uiMaxUniChar = (FLMUINT)puStaticPtr[ 0];
|
|
}
|
|
|
|
// WordPerfect
|
|
|
|
if( (FLMUINT)puStaticPtr[ 1] < gv_uiMinWPChar ||
|
|
!gv_uiMinWPChar)
|
|
{
|
|
flmAssert( puStaticPtr[ 1] != 0);
|
|
gv_uiMinWPChar = (FLMUINT)puStaticPtr[ 1];
|
|
}
|
|
|
|
if( (FLMUINT)puStaticPtr[ 1] > gv_uiMaxWPChar)
|
|
{
|
|
gv_uiMaxWPChar = (FLMUINT)puStaticPtr[ 1];
|
|
}
|
|
}
|
|
|
|
// Allocate the Unicode table
|
|
|
|
uiEntries = (gv_uiMaxUniChar - gv_uiMinUniChar) + 1;
|
|
if (RC_BAD( rc = f_calloc( uiEntries * sizeof( FLMUINT16),
|
|
&gv_pUnicodeToWP60)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
// Populate the Unicode table
|
|
|
|
for( uiLoop = 0, puStaticPtr = (FLMUINT16 *)WP_UTOWP60;
|
|
uiLoop < UTOWP60_ENTRIES; uiLoop++, puStaticPtr += 2)
|
|
{
|
|
uiOffset = (FLMUINT)puStaticPtr[ 0] - gv_uiMinUniChar;
|
|
|
|
flmAssert( gv_pUnicodeToWP60[ uiOffset] == 0);
|
|
gv_pUnicodeToWP60[ uiOffset] = puStaticPtr[ 1];
|
|
}
|
|
|
|
// Allocate the WordPerfect table
|
|
|
|
uiEntries = (gv_uiMaxWPChar - gv_uiMinWPChar) + 1;
|
|
if (RC_BAD( rc = f_calloc( uiEntries * sizeof( FLMUINT16),
|
|
&gv_pWP60ToUnicode)))
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
// Populate the WordPerfect table
|
|
|
|
for( uiLoop = 0, puStaticPtr = (FLMUINT16 *)WP_UTOWP60;
|
|
uiLoop < UTOWP60_ENTRIES; uiLoop++, puStaticPtr += 2)
|
|
{
|
|
uiOffset = (FLMUINT)puStaticPtr[ 1] - gv_uiMinWPChar;
|
|
|
|
flmAssert( gv_pWP60ToUnicode[ uiOffset] == 0);
|
|
gv_pWP60ToUnicode[ uiOffset] = puStaticPtr[ 0];
|
|
}
|
|
|
|
Exit:
|
|
|
|
if( RC_BAD( rc))
|
|
{
|
|
if( gv_pUnicodeToWP60)
|
|
{
|
|
f_free( &gv_pUnicodeToWP60);
|
|
}
|
|
|
|
if( gv_pWP60ToUnicode)
|
|
{
|
|
f_free( &gv_pWP60ToUnicode);
|
|
}
|
|
|
|
gv_uiMinUniChar = 0;
|
|
gv_uiMaxUniChar = 0;
|
|
|
|
gv_uiMinWPChar = 0;
|
|
gv_uiMaxWPChar = 0;
|
|
}
|
|
|
|
return( rc);
|
|
}
|
|
|
|
/****************************************************************************
|
|
Desc: Called by FlmShutdown, this routine frees the Unicode to WP and
|
|
WP to Unicode mapping tables.
|
|
****************************************************************************/
|
|
void F_DbSystem::freeCharMappingTables( void)
|
|
{
|
|
if( gv_pUnicodeToWP60)
|
|
{
|
|
f_free( &gv_pUnicodeToWP60);
|
|
}
|
|
|
|
if( gv_pWP60ToUnicode)
|
|
{
|
|
f_free( &gv_pWP60ToUnicode);
|
|
}
|
|
|
|
gv_uiMinUniChar = 0;
|
|
gv_uiMaxUniChar = 0;
|
|
|
|
gv_uiMinWPChar = 0;
|
|
gv_uiMaxWPChar = 0;
|
|
}
|