src/pinyin/pinyin_data.cpp

   1 /*
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   3  *
   4  * Copyright (c) 2007 Sun Microsystems, Inc. All Rights Reserved.
   5  *
   6  * The contents of this file are subject to the terms of either the GNU Lesser
   7  * General Public License Version 2.1 only ("LGPL") or the Common Development and
   8  * Distribution License ("CDDL")(collectively, the "License"). You may not use this
   9  * file except in compliance with the License. You can obtain a copy of the CDDL at
  10  * http://www.opensource.org/licenses/cddl1.php and a copy of the LGPLv2.1 at
  11  * http://www.opensource.org/licenses/lgpl-license.php. See the License for the
  12  * specific language governing permissions and limitations under the License. When
  13  * distributing the software, include this License Header Notice in each file and
  14  * include the full text of the License in the License file as well as the
  15  * following notice:
  16  *
  17  * NOTICE PURSUANT TO SECTION 9 OF THE COMMON DEVELOPMENT AND DISTRIBUTION LICENSE
  18  * (CDDL)
  19  * For Covered Software in this distribution, this License shall be governed by the
  20  * laws of the State of California (excluding conflict-of-law provisions).
  21  * Any litigation relating to this License shall be subject to the jurisdiction of
  22  * the Federal Courts of the Northern District of California and the state courts
  23  * of the State of California, with venue lying in Santa Clara County, California.
  24  *
  25  * Contributor(s):
  26  *
  27  * If you wish your version of this file to be governed by only the CDDL or only
  28  * the LGPL Version 2.1, indicate your decision by adding "[Contributor]" elects to
  29  * include this software in this distribution under the [CDDL or LGPL Version 2.1]
  30  * license." If you don't indicate a single choice of license, a recipient has the
  31  * option to distribute your version of this file under either the CDDL or the LGPL
  32  * Version 2.1, or to extend the choice of license to its licensees as provided
  33  * above. However, if you add LGPL Version 2.1 code and therefore, elected the LGPL
  34  * Version 2 license, then the option applies only if the new code is made subject
  35  * to such option by the copyright holder.
  36  */
  37
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include "pinyin_data.h"
  42
  43 static const char *initials[] =
  44 { "", "b", "p", "m", "f", "d", "t", "n", "l", "g", "k", "h", "j", "q", "x",
  45   "zh",
  46   "ch", "sh", "r", "z", "c", "s", "y", "w", };
  47 static const unsigned num_initials = sizeof(initials) / sizeof(*initials);
  48
  49 static const char *finals[] =
  50 { "", "a", "o", "e", "ai", "ei", "ao", "ou", "an", "en", "ang", "eng", "er",
  51   "i",
  52   "ia", "ie", "iao", "iu", "ian", "in", "iang", "ing", "u", "ua", "uo", "uai",
  53   "ui", "uan", "un", "uang", "ong", "v", "ue", "iong", };
  54 static const unsigned num_finals = sizeof(finals) / sizeof(*finals);
  55
  56 static const char *fuzzy_finals[] =
  57 { "ia", "iao", "ian", "iang", "ie", "ua", "uai", "uan", "uang", "ue" };
  58 static const unsigned num_fuzzy_finals = sizeof(fuzzy_finals) /
  59                                          sizeof(*fuzzy_finals);
  60
  61 static const unsigned fuzzy_finals_map[] = {
  62     0x0e, 0x10, 1,                         /* ia   -> a    len 1 */
  63     0x10, 0x60, 2,                         /* iao  -> ao   len 2 */
  64     0x12, 0x80, 2,                         /* ian  -> an   len 2 */
  65     0x14, 0xa0, 3,                         /* iang -> ang  len 3 */
  66     0x0f, 0x30, 1,                         /* ie   -> e    len 1 */
  67     0x17, 0x10, 1,                         /* ua   -> a    len 1 */
  68     0x19, 0x40, 2,                         /* uai  -> ai   len 2 */
  69     0x1b, 0x80, 2,                         /* uan  -> an   len 2 */
  70     0x1d, 0xa0, 3,                         /* uang -> ang  len 3 */
  71     0x20, 0x30, 1,                         /* ue   -> e    len 1 */
  72 };
  73
  74 static const unsigned fuzzy_pre_syllables [] = {
  75     0x0d0e0, 'n', 0x0d120,                 /* qian */
  76     0x09080, 'g', 0x090a0,                 /* gang */
  77     0x080e0, 'n', 0x08120,                 /* lian */
  78     0x15090, 'g', 0x150b0,                 /* seng */
  79     0x04010, 'n', 0x04080,                 /* fan */
  80     0x10030, 'n', 0x10090,                 /* chen */
  81     0x050e0, 'n', 0x05120,                 /* dian */
  82     0x15160, 'n', 0x151c0,                 /* sun */
  83     0x07080, 'g', 0x070a0,                 /* nang */
  84     0x0a160, 'n', 0x0a1c0,                 /* kun */
  85     0x05030, 'n', 0x05090,                 /* den */
  86     0x07090, 'g', 0x070b0,                 /* neng */
  87     0x03030, 'n', 0x03090,                 /* men */
  88     0x09090, 'g', 0x090b0,                 /* geng */
  89     0x10080, 'g', 0x100a0,                 /* chang */
  90     0x0f010, 'n', 0x0f080,                 /* zhan */
  91     0x14010, 'n', 0x14080,                 /* can */
  92     0x07130, 'g', 0x07150,                 /* ning */
  93     0x17080, 'g', 0x170a0,                 /* wang */
  94     0x01090, 'g', 0x010b0,                 /* beng */
  95     0x0f1b0, 'g', 0x0f1d0,                 /* zhuang */
  96     0x06010, 'n', 0x06080,                 /* tan */
  97     0x00090, 'g', 0x000b0,                 /* eng */
  98     0x0f080, 'g', 0x0f0a0,                 /* zhang */
  99     0x02130, 'g', 0x02150,                 /* ping */
 100     0x08010, 'n', 0x08080,                 /* lan */
 101     0x0e160, 'n', 0x0e1c0,                 /* xun */
 102     0x03010, 'n', 0x03080,                 /* man */
 103     0x0c120, 'g', 0x0c140,                 /* jiang */
 104     0x0a1b0, 'g', 0x0a1d0,                 /* kuang */
 105     0x01130, 'g', 0x01150,                 /* bing */
 106     0x13010, 'n', 0x13080,                 /* zan */
 107     0x13030, 'n', 0x13090,                 /* zen */
 108     0x02080, 'g', 0x020a0,                 /* pang */
 109     0x0c0d0, 'n', 0x0c130,                 /* jin */
 110     0x14030, 'n', 0x14090,                 /* cen */
 111     0x05010, 'n', 0x05080,                 /* dan */
 112     0x0f030, 'n', 0x0f090,                 /* zhen */
 113     0x01080, 'g', 0x010a0,                 /* bang */
 114     0x17090, 'g', 0x170b0,                 /* weng */
 115     0x00030, 'n', 0x00090,                 /* en */
 116     0x0a080, 'g', 0x0a0a0,                 /* kang */
 117     0x09160, 'n', 0x091c0,                 /* gun */
 118     0x00030, 'r', 0x000c0,                 /* er */
 119     0x0a090, 'g', 0x0a0b0,                 /* keng */
 120     0x15080, 'g', 0x150a0,                 /* sang */
 121     0x12030, 'n', 0x12090,                 /* ren */
 122     0x11160, 'n', 0x111c0,                 /* shun */
 123     0x0d160, 'n', 0x0d1c0,                 /* qun */
 124     0x16160, 'n', 0x161c0,                 /* yun */
 125     0x0e120, 'g', 0x0e140,                 /* xiang */
 126     0x12080, 'g', 0x120a0,                 /* rang */
 127     0x09170, 'n', 0x091b0,                 /* guan */
 128     0x16130, 'g', 0x16150,                 /* ying */
 129     0x0a170, 'n', 0x0a1b0,                 /* kuan */
 130     0x10010, 'n', 0x10080,                 /* chan */
 131     0x160d0, 'n', 0x16130,                 /* yin */
 132     0x0e0d0, 'n', 0x0e130,                 /* xin */
 133     0x07120, 'g', 0x07140,                 /* niang */
 134     0x0b160, 'n', 0x0b1c0,                 /* hun */
 135     0x11170, 'n', 0x111b0,                 /* shuan */
 136     0x05080, 'g', 0x050a0,                 /* dang */
 137     0x00080, 'g', 0x000a0,                 /* ang */
 138     0x15010, 'n', 0x15080,                 /* san */
 139     0x12090, 'g', 0x120b0,                 /* reng */
 140     0x03130, 'g', 0x03150,                 /* ming */
 141     0x030d0, 'n', 0x03130,                 /* min */
 142     0x07030, 'n', 0x07090,                 /* nen */
 143     0x0a010, 'n', 0x0a080,                 /* kan */
 144     0x16080, 'g', 0x160a0,                 /* yang */
 145     0x05090, 'g', 0x050b0,                 /* deng */
 146     0x101b0, 'g', 0x101d0,                 /* chuang */
 147     0x04090, 'g', 0x040b0,                 /* feng */
 148     0x03090, 'g', 0x030b0,                 /* meng */
 149     0x10090, 'g', 0x100b0,                 /* cheng */
 150     0x09030, 'n', 0x09090,                 /* gen */
 151     0x01010, 'n', 0x01080,                 /* ban */
 152     0x07160, 'n', 0x071c0,                 /* nun */
 153     0x15030, 'n', 0x15090,                 /* sen */
 154     0x04080, 'g', 0x040a0,                 /* fang */
 155     0x08160, 'n', 0x081c0,                 /* lun */
 156     0x0a030, 'n', 0x0a090,                 /* ken */
 157     0x0b1b0, 'g', 0x0b1d0,                 /* huang */
 158     0x03080, 'g', 0x030a0,                 /* mang */
 159     0x06160, 'n', 0x061c0,                 /* tun */
 160     0x0d0d0, 'n', 0x0d130,                 /* qin */
 161     0x02090, 'g', 0x020b0,                 /* peng */
 162     0x05160, 'n', 0x051c0,                 /* dun */
 163     0x10160, 'n', 0x101c0,                 /* chun */
 164     0x09010, 'n', 0x09080,                 /* gan */
 165     0x13090, 'g', 0x130b0,                 /* zeng */
 166     0x06080, 'g', 0x060a0,                 /* tang */
 167     0x14080, 'g', 0x140a0,                 /* cang */
 168     0x0b090, 'g', 0x0b0b0,                 /* heng */
 169     0x0e0e0, 'n', 0x0e120,                 /* xian */
 170     0x0f160, 'n', 0x0f1c0,                 /* zhun */
 171     0x111b0, 'g', 0x111d0,                 /* shuang */
 172     0x11010, 'n', 0x11080,                 /* shan */
 173     0x02010, 'n', 0x02080,                 /* pan */
 174     0x070d0, 'n', 0x07130,                 /* nin */
 175     0x0b080, 'g', 0x0b0a0,                 /* hang */
 176     0x0f170, 'n', 0x0f1b0,                 /* zhuan */
 177     0x080d0, 'n', 0x08130,                 /* lin */
 178     0x091b0, 'g', 0x091d0,                 /* guang */
 179     0x0b010, 'n', 0x0b080,                 /* han */
 180     0x14160, 'n', 0x141c0,                 /* cun */
 181     0x010d0, 'n', 0x01130,                 /* bin */
 182     0x11030, 'n', 0x11090,                 /* shen */
 183     0x0e130, 'g', 0x0e150,                 /* xing */
 184     0x0d120, 'g', 0x0d140,                 /* qiang */
 185     0x12160, 'n', 0x121c0,                 /* run */
 186     0x11090, 'g', 0x110b0,                 /* sheng */
 187     0x10170, 'n', 0x101b0,                 /* chuan */
 188     0x0d130, 'g', 0x0d150,                 /* qing */
 189     0x0c0e0, 'n', 0x0c120,                 /* jian */
 190     0x17010, 'n', 0x17080,                 /* wan */
 191     0x0c130, 'g', 0x0c150,                 /* jing */
 192     0x16010, 'n', 0x16080,                 /* yan */
 193     0x08120, 'g', 0x08140,                 /* liang */
 194     0x0b170, 'n', 0x0b1b0,                 /* huan */
 195     0x0b030, 'n', 0x0b090,                 /* hen */
 196     0x11080, 'g', 0x110a0,                 /* shang */
 197     0x0c160, 'n', 0x0c1c0,                 /* jun */
 198     0x08130, 'g', 0x08150,                 /* ling */
 199     0x14090, 'g', 0x140b0,                 /* ceng */
 200     0x020d0, 'n', 0x02130,                 /* pin */
 201     0x00010, 'n', 0x00080,                 /* an */
 202     0x13080, 'g', 0x130a0,                 /* zang */
 203     0x07010, 'n', 0x07080,                 /* nan */
 204     0x0f090, 'g', 0x0f0b0,                 /* zheng */
 205     0x13160, 'n', 0x131c0,                 /* zun */
 206     0x08080, 'g', 0x080a0,                 /* lang */
 207     0x0,
 208 };
 209
 210 static const unsigned fuzzy_pro_syllables [] = {
 211     0x09030, 'g', 0x00030,                 /* ge */
 212     0x090a0, 'g', 0x000a0,                 /* gang */
 213     0x09010, 'g', 0x00010,                 /* ga */
 214     0x12070, 'r', 0x00070,                 /* rou */
 215     0x07050, 'n', 0x00050,                 /* nei */
 216     0x070a0, 'n', 0x000a0,                 /* nang */
 217     0x070b0, 'n', 0x000b0,                 /* neng */
 218     0x090b0, 'g', 0x000b0,                 /* geng */
 219     0x07070, 'n', 0x00070,                 /* nou */
 220     0x12030, 'r', 0x00030,                 /* re */
 221     0x12090, 'r', 0x00090,                 /* ren */
 222     0x09070, 'g', 0x00070,                 /* gou */
 223     0x120a0, 'r', 0x000a0,                 /* rang */
 224     0x120b0, 'r', 0x000b0,                 /* reng */
 225     0x12080, 'r', 0x00080,                 /* ran */
 226     0x12060, 'r', 0x00060,                 /* rao */
 227     0x07090, 'n', 0x00090,                 /* nen */
 228     0x09050, 'g', 0x00050,                 /* gei */
 229     0x09090, 'g', 0x00090,                 /* gen */
 230     0x09060, 'g', 0x00060,                 /* gao */
 231     0x09080, 'g', 0x00080,                 /* gan */
 232     0x09040, 'g', 0x00040,                 /* gai */
 233     0x07060, 'n', 0x00060,                 /* nao */
 234     0x07010, 'n', 0x00010,                 /* na */
 235     0x07040, 'n', 0x00040,                 /* nai */
 236     0x07080, 'n', 0x00080,                 /* nan */
 237     0x07030, 'n', 0x00030,                 /* ne */
 238     0x0,
 239 };
 240
 241 static const char * fuzzy_pairs[] = {
 242     "z", "zh",
 243     "c", "ch",
 244     "s", "sh",
 245     "an", "ang",
 246     "on", "ong",
 247     "en", "eng",
 248     "in", "ing",
 249     "eng", "ong",
 250     "ian", "iang",
 251     "uan", "uang",
 252     "l", "n",
 253     "f", "h",
 254     "r", "l",
 255     "k", "g",
 256 };
 257 static const unsigned num_fuzzy_pairs = sizeof(fuzzy_pairs) /
 258                                         sizeof(*fuzzy_pairs) / 2;
 259
 260 static const char * auto_correction_pairs[] = {
 261     "ign", "ing",
 262     "img", "ing",
 263     "uei", "ui",
 264     "uen", "un",
 265     "iou", "iu",
 266 };
 267 static const unsigned num_auto_correction_pairs =
 268     sizeof(auto_correction_pairs) / sizeof(*auto_correction_pairs) / 2;
 269
 270 static const TPyTabEntry
 271     pinyin_table[] = {
 272     { "a", 0x00010 },
 273     { "ai", 0x00040 },
 274     { "an", 0x00080 },
 275     { "ang", 0x000a0 },
 276     { "ao", 0x00060 },
 277     { "b", 0x01000 },
 278     { "ba", 0x01010 },
 279     { "bai", 0x01040 },
 280     { "ban", 0x01080 },
 281     { "bang", 0x010a0 },
 282     { "bao", 0x01060 },
 283     { "bei", 0x01050 },
 284     { "ben", 0x01090 },
 285     { "beng", 0x010b0 },
 286     { "bi", 0x010d0 },
 287     { "bian", 0x01120 },
 288     { "biao", 0x01100 },
 289     { "bie", 0x010f0 },
 290     { "bin", 0x01130 },
 291     { "bing", 0x01150 },
 292     { "bo", 0x01020 },
 293     { "bu", 0x01160 },
 294     { "c", 0x14000 },
 295     { "ca", 0x14010 },
 296     { "cai", 0x14040 },
 297     { "can", 0x14080 },
 298     { "cang", 0x140a0 },
 299     { "cao", 0x14060 },
 300     { "ce", 0x14030 },
 301     { "cei", 0x14050 },
 302     { "cen", 0x14090 },
 303     { "ceng", 0x140b0 },
 304     { "ch", 0x10000 },
 305     { "cha", 0x10010 },
 306     { "chai", 0x10040 },
 307     { "chan", 0x10080 },
 308     { "chang", 0x100a0 },
 309     { "chao", 0x10060 },
 310     { "che", 0x10030 },
 311     { "chen", 0x10090 },
 312     { "cheng", 0x100b0 },
 313     { "chi", 0x100d0 },
 314     { "chong", 0x101e0 },
 315     { "chou", 0x10070 },
 316     { "chu", 0x10160 },
 317     { "chua", 0x10170 },
 318     { "chuai", 0x10190 },
 319     { "chuan", 0x101b0 },
 320     { "chuang", 0x101d0 },
 321     { "chui", 0x101a0 },
 322     { "chun", 0x101c0 },
 323     { "chuo", 0x10180 },
 324     { "ci", 0x140d0 },
 325     { "cong", 0x141e0 },
 326     { "cou", 0x14070 },
 327     { "cu", 0x14160 },
 328     { "cuan", 0x141b0 },
 329     { "cui", 0x141a0 },
 330     { "cun", 0x141c0 },
 331     { "cuo", 0x14180 },
 332     { "d", 0x05000 },
 333     { "da", 0x05010 },
 334     { "dai", 0x05040 },
 335     { "dan", 0x05080 },
 336     { "dang", 0x050a0 },
 337     { "dao", 0x05060 },
 338     { "de", 0x05030 },
 339     { "dei", 0x05050 },
 340     { "den", 0x05090 },
 341     { "deng", 0x050b0 },
 342     { "di", 0x050d0 },
 343     { "dia", 0x050e0 },
 344     { "dian", 0x05120 },
 345     { "diao", 0x05100 },
 346     { "die", 0x050f0 },
 347     { "ding", 0x05150 },
 348     { "diu", 0x05110 },
 349     { "dong", 0x051e0 },
 350     { "dou", 0x05070 },
 351     { "du", 0x05160 },
 352     { "duan", 0x051b0 },
 353     { "dui", 0x051a0 },
 354     { "dun", 0x051c0 },
 355     { "duo", 0x05180 },
 356     { "e", 0x00030 },
 357     { "ei", 0x00050 },
 358     { "en", 0x00090 },
 359     { "eng", 0x000b0 },
 360     { "er", 0x000c0 },
 361     { "f", 0x04000 },
 362     { "fa", 0x04010 },
 363     { "fan", 0x04080 },
 364     { "fang", 0x040a0 },
 365     { "fei", 0x04050 },
 366     { "fen", 0x04090 },
 367     { "feng", 0x040b0 },
 368     { "fiao", 0x04100 },
 369     { "fo", 0x04020 },
 370     { "fou", 0x04070 },
 371     { "fu", 0x04160 },
 372     { "g", 0x09000 },
 373     { "ga", 0x09010 },
 374     { "gai", 0x09040 },
 375     { "gan", 0x09080 },
 376     { "gang", 0x090a0 },
 377     { "gao", 0x09060 },
 378     { "ge", 0x09030 },
 379     { "gei", 0x09050 },
 380     { "gen", 0x09090 },
 381     { "geng", 0x090b0 },
 382     { "gong", 0x091e0 },
 383     { "gou", 0x09070 },
 384     { "gu", 0x09160 },
 385     { "gua", 0x09170 },
 386     { "guai", 0x09190 },
 387     { "guan", 0x091b0 },
 388     { "guang", 0x091d0 },
 389     { "gui", 0x091a0 },
 390     { "gun", 0x091c0 },
 391     { "guo", 0x09180 },
 392     { "h", 0x0b000 },
 393     { "ha", 0x0b010 },
 394     { "hai", 0x0b040 },
 395     { "han", 0x0b080 },
 396     { "hang", 0x0b0a0 },
 397     { "hao", 0x0b060 },
 398     { "he", 0x0b030 },
 399     { "hei", 0x0b050 },
 400     { "hen", 0x0b090 },
 401     { "heng", 0x0b0b0 },
 402     { "hong", 0x0b1e0 },
 403     { "hou", 0x0b070 },
 404     { "hu", 0x0b160 },
 405     { "hua", 0x0b170 },
 406     { "huai", 0x0b190 },
 407     { "huan", 0x0b1b0 },
 408     { "huang", 0x0b1d0 },
 409     { "hui", 0x0b1a0 },
 410     { "hun", 0x0b1c0 },
 411     { "huo", 0x0b180 },
 412     { "j", 0x0c000 },
 413     { "ji", 0x0c0d0 },
 414     { "jia", 0x0c0e0 },
 415     { "jian", 0x0c120 },
 416     { "jiang", 0x0c140 },
 417     { "jiao", 0x0c100 },
 418     { "jie", 0x0c0f0 },
 419     { "jin", 0x0c130 },
 420     { "jing", 0x0c150 },
 421     { "jiong", 0x0c210 },
 422     { "jiu", 0x0c110 },
 423     { "ju", 0x0c160 },
 424     { "juan", 0x0c1b0 },
 425     { "jue", 0x0c200 },
 426     { "jun", 0x0c1c0 },
 427     { "k", 0x0a000 },
 428     { "ka", 0x0a010 },
 429     { "kai", 0x0a040 },
 430     { "kan", 0x0a080 },
 431     { "kang", 0x0a0a0 },
 432     { "kao", 0x0a060 },
 433     { "ke", 0x0a030 },
 434     { "kei", 0x0a050 },
 435     { "ken", 0x0a090 },
 436     { "keng", 0x0a0b0 },
 437     { "kong", 0x0a1e0 },
 438     { "kou", 0x0a070 },
 439     { "ku", 0x0a160 },
 440     { "kua", 0x0a170 },
 441     { "kuai", 0x0a190 },
 442     { "kuan", 0x0a1b0 },
 443     { "kuang", 0x0a1d0 },
 444     { "kui", 0x0a1a0 },
 445     { "kun", 0x0a1c0 },
 446     { "kuo", 0x0a180 },
 447     { "l", 0x08000 },
 448     { "la", 0x08010 },
 449     { "lai", 0x08040 },
 450     { "lan", 0x08080 },
 451     { "lang", 0x080a0 },
 452     { "lao", 0x08060 },
 453     { "le", 0x08030 },
 454     { "lei", 0x08050 },
 455     { "leng", 0x080b0 },
 456     { "li", 0x080d0 },
 457     { "lia", 0x080e0 },
 458     { "lian", 0x08120 },
 459     { "liang", 0x08140 },
 460     { "liao", 0x08100 },
 461     { "lie", 0x080f0 },
 462     { "lin", 0x08130 },
 463     { "ling", 0x08150 },
 464     { "liu", 0x08110 },
 465     { "lo", 0x08020 },
 466     { "long", 0x081e0 },
 467     { "lou", 0x08070 },
 468     { "lu", 0x08160 },
 469     { "luan", 0x081b0 },
 470     { "lue", 0x08200 },
 471     { "lun", 0x081c0 },
 472     { "luo", 0x08180 },
 473     { "lv", 0x081f0 },
 474     { "m", 0x03000 },
 475     { "ma", 0x03010 },
 476     { "mai", 0x03040 },
 477     { "man", 0x03080 },
 478     { "mang", 0x030a0 },
 479     { "mao", 0x03060 },
 480     { "me", 0x03030 },
 481     { "mei", 0x03050 },
 482     { "men", 0x03090 },
 483     { "meng", 0x030b0 },
 484     { "mi", 0x030d0 },
 485     { "mian", 0x03120 },
 486     { "miao", 0x03100 },
 487     { "mie", 0x030f0 },
 488     { "min", 0x03130 },
 489     { "ming", 0x03150 },
 490     { "miu", 0x03110 },
 491     { "mo", 0x03020 },
 492     { "mou", 0x03070 },
 493     { "mu", 0x03160 },
 494     { "n", 0x07000 },
 495     { "na", 0x07010 },
 496     { "nai", 0x07040 },
 497     { "nan", 0x07080 },
 498     { "nang", 0x070a0 },
 499     { "nao", 0x07060 },
 500     { "ne", 0x07030 },
 501     { "nei", 0x07050 },
 502     { "nen", 0x07090 },
 503     { "neng", 0x070b0 },
 504     { "ni", 0x070d0 },
 505     { "nian", 0x07120 },
 506     { "niang", 0x07140 },
 507     { "niao", 0x07100 },
 508     { "nie", 0x070f0 },
 509     { "nin", 0x07130 },
 510     { "ning", 0x07150 },
 511     { "niu", 0x07110 },
 512     { "nong", 0x071e0 },
 513     { "nou", 0x07070 },
 514     { "nu", 0x07160 },
 515     { "nuan", 0x071b0 },
 516     { "nue", 0x07200 },
 517     { "nun", 0x071c0 },
 518     { "nuo", 0x07180 },
 519     { "nv", 0x071f0 },
 520     { "o", 0x00020 },
 521     { "ou", 0x00070 },
 522     { "p", 0x02000 },
 523     { "pa", 0x02010 },
 524     { "pai", 0x02040 },
 525     { "pan", 0x02080 },
 526     { "pang", 0x020a0 },
 527     { "pao", 0x02060 },
 528     { "pei", 0x02050 },
 529     { "pen", 0x02090 },
 530     { "peng", 0x020b0 },
 531     { "pi", 0x020d0 },
 532     { "pian", 0x02120 },
 533     { "piao", 0x02100 },
 534     { "pie", 0x020f0 },
 535     { "pin", 0x02130 },
 536     { "ping", 0x02150 },
 537     { "po", 0x02020 },
 538     { "pou", 0x02070 },
 539     { "pu", 0x02160 },
 540     { "q", 0x0d000 },
 541     { "qi", 0x0d0d0 },
 542     { "qia", 0x0d0e0 },
 543     { "qian", 0x0d120 },
 544     { "qiang", 0x0d140 },
 545     { "qiao", 0x0d100 },
 546     { "qie", 0x0d0f0 },
 547     { "qin", 0x0d130 },
 548     { "qing", 0x0d150 },
 549     { "qiong", 0x0d210 },
 550     { "qiu", 0x0d110 },
 551     { "qu", 0x0d160 },
 552     { "quan", 0x0d1b0 },
 553     { "que", 0x0d200 },
 554     { "qun", 0x0d1c0 },
 555     { "r", 0x12000 },
 556     { "ran", 0x12080 },
 557     { "rang", 0x120a0 },
 558     { "rao", 0x12060 },
 559     { "re", 0x12030 },
 560     { "ren", 0x12090 },
 561     { "reng", 0x120b0 },
 562     { "ri", 0x120d0 },
 563     { "rong", 0x121e0 },
 564     { "rou", 0x12070 },
 565     { "ru", 0x12160 },
 566     { "ruan", 0x121b0 },
 567     { "rui", 0x121a0 },
 568     { "run", 0x121c0 },
 569     { "ruo", 0x12180 },
 570     { "s", 0x15000 },
 571     { "sa", 0x15010 },
 572     { "sai", 0x15040 },
 573     { "san", 0x15080 },
 574     { "sang", 0x150a0 },
 575     { "sao", 0x15060 },
 576     { "se", 0x15030 },
 577     { "sen", 0x15090 },
 578     { "seng", 0x150b0 },
 579     { "sh", 0x11000 },
 580     { "sha", 0x11010 },
 581     { "shai", 0x11040 },
 582     { "shan", 0x11080 },
 583     { "shang", 0x110a0 },
 584     { "shao", 0x11060 },
 585     { "she", 0x11030 },
 586     { "shei", 0x11050 },
 587     { "shen", 0x11090 },
 588     { "sheng", 0x110b0 },
 589     { "shi", 0x110d0 },
 590     { "shou", 0x11070 },
 591     { "shu", 0x11160 },
 592     { "shua", 0x11170 },
 593     { "shuai", 0x11190 },
 594     { "shuan", 0x111b0 },
 595     { "shuang", 0x111d0 },
 596     { "shui", 0x111a0 },
 597     { "shun", 0x111c0 },
 598     { "shuo", 0x11180 },
 599     { "si", 0x150d0 },
 600     { "song", 0x151e0 },
 601     { "sou", 0x15070 },
 602     { "su", 0x15160 },
 603     { "suan", 0x151b0 },
 604     { "sui", 0x151a0 },
 605     { "sun", 0x151c0 },
 606     { "suo", 0x15180 },
 607     { "t", 0x06000 },
 608     { "ta", 0x06010 },
 609     { "tai", 0x06040 },
 610     { "tan", 0x06080 },
 611     { "tang", 0x060a0 },
 612     { "tao", 0x06060 },
 613     { "te", 0x06030 },
 614     { "tei", 0x06050 },
 615     { "teng", 0x060b0 },
 616     { "ti", 0x060d0 },
 617     { "tian", 0x06120 },
 618     { "tiao", 0x06100 },
 619     { "tie", 0x060f0 },
 620     { "ting", 0x06150 },
 621     { "tong", 0x061e0 },
 622     { "tou", 0x06070 },
 623     { "tu", 0x06160 },
 624     { "tuan", 0x061b0 },
 625     { "tui", 0x061a0 },
 626     { "tun", 0x061c0 },
 627     { "tuo", 0x06180 },
 628     { "w", 0x17000 },
 629     { "wa", 0x17010 },
 630     { "wai", 0x17040 },
 631     { "wan", 0x17080 },
 632     { "wang", 0x170a0 },
 633     { "wei", 0x17050 },
 634     { "wen", 0x17090 },
 635     { "weng", 0x170b0 },
 636     { "wo", 0x17020 },
 637     { "wu", 0x17160 },
 638     { "x", 0x0e000 },
 639     { "xi", 0x0e0d0 },
 640     { "xia", 0x0e0e0 },
 641     { "xian", 0x0e120 },
 642     { "xiang", 0x0e140 },
 643     { "xiao", 0x0e100 },
 644     { "xie", 0x0e0f0 },
 645     { "xin", 0x0e130 },
 646     { "xing", 0x0e150 },
 647     { "xiong", 0x0e210 },
 648     { "xiu", 0x0e110 },
 649     { "xu", 0x0e160 },
 650     { "xuan", 0x0e1b0 },
 651     { "xue", 0x0e200 },
 652     { "xun", 0x0e1c0 },
 653     { "y", 0x16000 },
 654     { "ya", 0x16010 },
 655     { "yan", 0x16080 },
 656     { "yang", 0x160a0 },
 657     { "yao", 0x16060 },
 658     { "ye", 0x16030 },
 659     { "yi", 0x160d0 },
 660     { "yin", 0x16130 },
 661     { "ying", 0x16150 },
 662     { "yo", 0x16020 },
 663     { "yong", 0x161e0 },
 664     { "you", 0x16070 },
 665     { "yu", 0x16160 },
 666     { "yuan", 0x161b0 },
 667     { "yue", 0x16200 },
 668     { "yun", 0x161c0 },
 669     { "z", 0x13000 },
 670     { "za", 0x13010 },
 671     { "zai", 0x13040 },
 672     { "zan", 0x13080 },
 673     { "zang", 0x130a0 },
 674     { "zao", 0x13060 },
 675     { "ze", 0x13030 },
 676     { "zei", 0x13050 },
 677     { "zen", 0x13090 },
 678     { "zeng", 0x130b0 },
 679     { "zh", 0x0f000 },
 680     { "zha", 0x0f010 },
 681     { "zhai", 0x0f040 },
 682     { "zhan", 0x0f080 },
 683     { "zhang", 0x0f0a0 },
 684     { "zhao", 0x0f060 },
 685     { "zhe", 0x0f030 },
 686     { "zhei", 0x0f050 },
 687     { "zhen", 0x0f090 },
 688     { "zheng", 0x0f0b0 },
 689     { "zhi", 0x0f0d0 },
 690     { "zhong", 0x0f1e0 },
 691     { "zhou", 0x0f070 },
 692     { "zhu", 0x0f160 },
 693     { "zhua", 0x0f170 },
 694     { "zhuai", 0x0f190 },
 695     { "zhuan", 0x0f1b0 },
 696     { "zhuang", 0x0f1d0 },
 697     { "zhui", 0x0f1a0 },
 698     { "zhun", 0x0f1c0 },
 699     { "zhuo", 0x0f180 },
 700     { "zi", 0x130d0 },
 701     { "zong", 0x131e0 },
 702     { "zou", 0x13070 },
 703     { "zu", 0x13160 },
 704     { "zuan", 0x131b0 },
 705     { "zui", 0x131a0 },
 706     { "zun", 0x131c0 },
 707     { "zuo", 0x13180 },
 708 };
 709
 710 static int
 711 pytab_entry_compare(const char *s, TPyTabEntry *v)
 712 {
 713     return strcmp(s, v->pystr);
 714 }
 715
 716 TSyllable
 717 CPinyinData::encodeSyllable(const char *pinyin)
 718 {
 719     typedef int (*bsearch_compare)(const void*, const void*);
 720     TPyTabEntry *e = (TPyTabEntry*)bsearch(pinyin, pinyin_table,
 721                                            sizeof(pinyin_table) /
 722                                            sizeof(pinyin_table[0]),
 723                                            sizeof(pinyin_table[0]),
 724                                            (bsearch_compare)pytab_entry_compare);
 725     if (e)
 726         return e->id;
 727
 728     return 0;
 729 }
 730
 731 const char *
 732 CPinyinData::decodeSyllable(TSyllable s, const char **i, const char **f)
 733 {
 734     if (i) *i = initials[s.initial];
 735     if (f) *f = finals[s.final];
 736
 737     static char buf[128];
 738     snprintf(buf, sizeof(buf), "%s%s", initials[s.initial], finals[s.final]);
 739
 740     typedef int (*bsearch_compare)(const void*, const void*);
 741     TPyTabEntry *e = (TPyTabEntry*)bsearch(buf, pinyin_table,
 742                                            sizeof(pinyin_table) /
 743                                            sizeof(pinyin_table[0]),
 744                                            sizeof(pinyin_table[0]),
 745                                            (bsearch_compare)pytab_entry_compare);
 746
 747     if (e)
 748         return e->pystr;
 749
 750     return NULL;
 751 }
 752
 753 const char **
 754 CPinyinData::getAutoCorrectionPairs(unsigned &num)
 755 {
 756     num = num_auto_correction_pairs;
 757     return auto_correction_pairs;
 758 }
 759
 760 const char **
 761 CPinyinData::getFuzzyPairs(unsigned &num)
 762 {
 763     num = num_fuzzy_pairs;
 764     return fuzzy_pairs;
 765 }
 766
 767 const char **
 768 CPinyinData::getInitials(unsigned &num)
 769 {
 770     num = num_initials;
 771     return initials;
 772 }
 773
 774 const char **
 775 CPinyinData::getFinals(unsigned &num)
 776 {
 777     num = num_finals;
 778     return finals;
 779 }
 780
 781 const TPyTabEntry *
 782 CPinyinData::getPinyinTable(unsigned &num)
 783 {
 784     num = sizeof(pinyin_table) / sizeof(TPyTabEntry);
 785     return pinyin_table;
 786 }
 787
 788 const unsigned *
 789 CPinyinData::getInnerFuzzyFinalMap(unsigned &num)
 790 {
 791     num = num_fuzzy_finals;
 792     return fuzzy_finals_map;
 793 }
 794
 795 void
 796 CPinyinData::getFuzzyPreProSyllables(const unsigned **pre_syls,
 797                                      const unsigned **pro_syls)
 798 {
 799     *pre_syls = fuzzy_pre_syllables;
 800     *pro_syls = fuzzy_pro_syllables;
 801 }