开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
conv.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：21k
源码类别：

数据库系统

开发平台：

Unix_Linux

conv.c：源码内容
  1. /*
  2.  * conversion between client encoding and server internal encoding
  3.  * (currently mule internal code (mic) is used)
  4.  * Tatsuo Ishii
  5.  * WIN1250 client encoding support contributed by Pavel Behal
  6.  *
  7.  * $Id: conv.c,v 1.12 1999/07/11 22:47:20 ishii Exp $
  8.  *
  9.  *
  10.  */
  12. #include <stdio.h>
  13. #include <string.h>
  15. #include "mb/pg_wchar.h"
  17. /*
  18.  * convert bogus chars that cannot be represented in the current
  19. encoding
  20.  * system.
  21.  */
  22. static void
  23. printBogusChar(unsigned char **mic, unsigned char **p)
  24. {
  25. char strbuf[16];
  26. int l = pg_mic_mblen(*mic);
  28. *(*p)++ = '(';
  29. while (l--)
  30. {
  31. sprintf(strbuf, "%02x", *(*mic)++);
  32. *(*p)++ = strbuf[0];
  33. *(*p)++ = strbuf[1];
  34. }
  35. *(*p)++ = ')';
  36. }
  38. /*
  39.  * SJIS ---> MIC
  40.  */
  41. static void
  42. sjis2mic(unsigned char *sjis, unsigned char *p, int len)
  43. {
  44. int c1,
  45. c2;
  47. while (len > 0 && (c1 = *sjis++))
  48. {
  49. if (c1 >= 0xa1 && c1 <= 0xdf)
  50. { /* 1 byte kana? */
  51. len--;
  52. *p++ = LC_JISX0201K;
  53. *p++ = c1;
  54. }
  55. else if (c1 > 0x7f)
  56. { /* kanji? */
  57. c2 = *sjis++;
  58. len -= 2;
  59. *p++ = LC_JISX0208;
  60. *p++ = ((c1 & 0x3f) << 1) + 0x9f + (c2 > 0x9e);
  61. *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
  62. }
  63. else
  64. { /* should be ASCII */
  65. len--;
  66. *p++ = c1;
  67. }
  68. }
  69. *p = '';
  70. }
  72. /*
  73.  * MIC ---> SJIS
  74.  */
  75. static void
  76. mic2sjis(unsigned char *mic, unsigned char *p, int len)
  77. {
  78. int c1,
  79. c2;
  81. while (len > 0 && (c1 = *mic))
  82. {
  83. len -= pg_mic_mblen(mic++);
  85. if (c1 == LC_JISX0201K)
  86. *p++ = *mic++;
  87. else if (c1 == LC_JISX0208)
  88. {
  89. c1 = *mic++;
  90. c2 = *mic++;
  91. *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1);
  92. *p++ = c2 - ((c1 & 1) ? ((c2 < 0xe0) ? 0x61 : 0x60) : 2);
  93. }
  94. else if (c1 > 0x7f)
  95. { /* cannot convert to SJIS! */
  96. mic--;
  97. printBogusChar(&mic, &p);
  98. }
  99. else
  100. { /* should be ASCII */
  101. *p++ = c1;
  102. }
  103. }
  104. *p = '';
  105. }
  107. /*
  108.  * EUC_JP ---> MIC
  109.  */
  110. static void
  111. euc_jp2mic(unsigned char *euc, unsigned char *p, int len)
  112. {
  113. int c1;
  115. while (len > 0 && (c1 = *euc++))
  116. {
  117. if (c1 == SS2)
  118. { /* 1 byte kana? */
  119. len -= 2;
  120. *p++ = LC_JISX0201K;
  121. *p++ = *euc++;
  122. }
  123. else if (c1 == SS3)
  124. { /* JIS X0212 kanji? */
  125. len -= 3;
  126. *p++ = LC_JISX0212;
  127. *p++ = *euc++;
  128. *p++ = *euc++;
  129. }
  130. else if (c1 & 0x80)
  131. { /* kanji? */
  132. len -= 2;
  133. *p++ = LC_JISX0208;
  134. *p++ = c1;
  135. *p++ = *euc++;
  136. }
  137. else
  138. { /* should be ASCII */
  139. len--;
  140. *p++ = c1;
  141. }
  142. }
  143. *p = '';
  144. }
  146. /*
  147.  * MIC ---> EUC_JP
  148.  */
  149. static void
  150. mic2euc_jp(unsigned char *mic, unsigned char *p, int len)
  151. {
  152. int c1;
  154. while (len > 0 && (c1 = *mic))
  155. {
  156. len -= pg_mic_mblen(mic++);
  158. if (c1 == LC_JISX0201K)
  159. {
  160. *p++ = SS2;
  161. *p++ = *mic++;
  162. }
  163. else if (c1 == LC_JISX0212)
  164. {
  165. *p++ = SS3;
  166. *p++ = *mic++;
  167. *p++ = *mic++;
  168. }
  169. else if (c1 == LC_JISX0208)
  170. {
  171. *p++ = *mic++;
  172. *p++ = *mic++;
  173. }
  174. else if (c1 > 0x7f)
  175. { /* cannot convert to EUC_JP! */
  176. mic--;
  177. printBogusChar(&mic, &p);
  178. }
  179. else
  180. { /* should be ASCII */
  181. *p++ = c1;
  182. }
  183. }
  184. *p = '';
  185. }
  187. /*
  188.  * EUC_KR ---> MIC
  189.  */
  190. static void
  191. euc_kr2mic(unsigned char *euc, unsigned char *p, int len)
  192. {
  193. int c1;
  195. while (len > 0 && (c1 = *euc++))
  196. {
  197. if (c1 & 0x80)
  198. {
  199. len -= 2;
  200. *p++ = LC_KS5601;
  201. *p++ = c1;
  202. *p++ = *euc++;
  203. }
  204. else
  205. { /* should be ASCII */
  206. len--;
  207. *p++ = c1;
  208. }
  209. }
  210. *p = '';
  211. }
  213. /*
  214.  * MIC ---> EUC_KR
  215.  */
  216. static void
  217. mic2euc_kr(unsigned char *mic, unsigned char *p, int len)
  218. {
  219. int c1;
  221. while (len > 0 && (c1 = *mic))
  222. {
  223. len -= pg_mic_mblen(mic++);
  225. if (c1 == LC_KS5601)
  226. {
  227. *p++ = *mic++;
  228. *p++ = *mic++;
  229. }
  230. else if (c1 > 0x7f)
  231. { /* cannot convert to EUC_KR! */
  232. mic--;
  233. printBogusChar(&mic, &p);
  234. }
  235. else
  236. { /* should be ASCII */
  237. *p++ = c1;
  238. }
  239. }
  240. *p = '';
  241. }
  243. /*
  244.  * EUC_CN ---> MIC
  245.  */
  246. static void
  247. euc_cn2mic(unsigned char *euc, unsigned char *p, int len)
  248. {
  249. int c1;
  251. while (len > 0 && (c1 = *euc++))
  252. {
  253. if (c1 & 0x80)
  254. {
  255. len -= 2;
  256. *p++ = LC_GB2312_80;
  257. *p++ = c1;
  258. *p++ = *euc++;
  259. }
  260. else
  261. { /* should be ASCII */
  262. len--;
  263. *p++ = c1;
  264. }
  265. }
  266. *p = '';
  267. }
  269. /*
  270.  * MIC ---> EUC_CN
  271.  */
  272. static void
  273. mic2euc_cn(unsigned char *mic, unsigned char *p, int len)
  274. {
  275. int c1;
  277. while (len > 0 && (c1 = *mic))
  278. {
  279. len -= pg_mic_mblen(mic++);
  281. if (c1 == LC_GB2312_80)
  282. {
  283. *p++ = *mic++;
  284. *p++ = *mic++;
  285. }
  286. else if (c1 > 0x7f)
  287. { /* cannot convert to EUC_CN! */
  288. mic--;
  289. printBogusChar(&mic, &p);
  290. }
  291. else
  292. { /* should be ASCII */
  293. *p++ = c1;
  294. }
  295. }
  296. *p = '';
  297. }
  299. /*
  300.  * EUC_TW ---> MIC
  301.  */
  302. static void
  303. euc_tw2mic(unsigned char *euc, unsigned char *p, int len)
  304. {
  305. int c1;
  307. while (len > 0 && (c1 = *euc++))
  308. {
  309. if (c1 == SS2)
  310. {
  311. len -= 4;
  312. c1 = *euc++; /* plane No. */
  313. if (c1 == 0xa1)
  314. *p++ = LC_CNS11643_1;
  315. else if (c1 == 0xa2)
  316. *p++ = LC_CNS11643_2;
  317. else
  318. {
  319. *p++ = 0x9d; /* LCPRV2 */
  320. *p++ = 0xa3 - c1 + LC_CNS11643_3;
  321. }
  322. *p++ = *euc++;
  323. *p++ = *euc++;
  324. }
  325. else if (c1 & 0x80)
  326. { /* CNS11643-1 */
  327. len -= 2;
  328. *p++ = LC_CNS11643_1;
  329. *p++ = c1;
  330. *p++ = *euc++;
  331. }
  332. else
  333. { /* should be ASCII */
  334. len--;
  335. *p++ = c1;
  336. }
  337. }
  338. *p = '';
  339. }
  341. /*
  342.  * MIC ---> EUC_TW
  343.  */
  344. static void
  345. mic2euc_tw(unsigned char *mic, unsigned char *p, int len)
  346. {
  347. int c1;
  349. while (len > 0 && (c1 = *mic))
  350. {
  351. len -= pg_mic_mblen(mic++);
  353. if (c1 == LC_CNS11643_1 || c1 == LC_CNS11643_2)
  354. {
  355. *p++ = *mic++;
  356. *p++ = *mic++;
  357. }
  358. else if (c1 == 0x9d)
  359. { /* LCPRV2? */
  360. *p++ = SS2;
  361. *p++ = c1 - LC_CNS11643_3 + 0xa3;
  362. *p++ = *mic++;
  363. *p++ = *mic++;
  364. }
  365. else if (c1 > 0x7f)
  366. { /* cannot convert to EUC_TW! */
  367. mic--;
  368. printBogusChar(&mic, &p);
  369. }
  370. else
  371. { /* should be ASCII */
  372. *p++ = c1;
  373. }
  374. }
  375. *p = '';
  376. }
  378. /*
  379.  * Big5 ---> MIC
  380.  */
  381. static void
  382. big52mic(unsigned char *big5, unsigned char *p, int len)
  383. {
  384. unsigned short c1;
  385. unsigned short big5buf,
  386. cnsBuf;
  387. unsigned char lc;
  388. char bogusBuf[2];
  389. int i;
  391. while (len > 0 && (c1 = *big5++))
  392. {
  393. if (c1 <= 0x7fU)
  394. { /* ASCII */
  395. len--;
  396. *p++ = c1;
  397. }
  398. else
  399. {
  400. len -= 2;
  401. big5buf = c1 << 8;
  402. c1 = *big5++;
  403. big5buf |= c1;
  404. cnsBuf = BIG5toCNS(big5buf, &lc);
  405. if (lc != 0)
  406. {
  407. if (lc == LC_CNS11643_3 || lc == LC_CNS11643_4)
  408. {
  409. *p++ = 0x9d;/* LCPRV2 */
  410. }
  411. *p++ = lc; /* Plane No. */
  412. *p++ = (cnsBuf >> 8) & 0x00ff;
  413. *p++ = cnsBuf & 0x00ff;
  414. }
  415. else
  416. { /* cannot convert */
  417. big5 -= 2;
  418. *p++ = '(';
  419. for (i = 0; i < 2; i++)
  420. {
  421. sprintf(bogusBuf, "%02x", *big5++);
  422. *p++ = bogusBuf[0];
  423. *p++ = bogusBuf[1];
  424. }
  425. *p++ = ')';
  426. }
  427. }
  428. }
  429. *p = '';
  430. }
  432. /*
  433.  * MIC ---> Big5
  434.  */
  435. static void
  436. mic2big5(unsigned char *mic, unsigned char *p, int len)
  437. {
  438. int l;
  439. unsigned short c1;
  440. unsigned short big5buf,
  441. cnsBuf;
  443. while (len > 0 && (c1 = *mic))
  444. {
  445. l = pg_mic_mblen(mic++);
  446. len -= l;
  448. /* 0x9d means LCPRV2 */
  449. if (c1 == LC_CNS11643_1 || c1 == LC_CNS11643_2 || c1 == 0x9d)
  450. {
  451. if (c1 == 0x9d)
  452. {
  453. c1 = *mic++; /* get plane no. */
  454. }
  455. cnsBuf = (*mic++) << 8;
  456. cnsBuf |= (*mic++) & 0x00ff;
  457. big5buf = CNStoBIG5(cnsBuf, c1);
  458. if (big5buf == 0)
  459. { /* cannot convert to Big5! */
  460. mic -= l;
  461. printBogusChar(&mic, &p);
  462. }
  463. else
  464. {
  465. *p++ = (big5buf >> 8) & 0x00ff;
  466. *p++ = big5buf & 0x00ff;
  467. }
  468. }
  469. else if (c1 <= 0x7f) /* ASCII */
  470. *p++ = c1;
  471. else
  472. { /* cannot convert to Big5! */
  473. mic--;
  474. printBogusChar(&mic, &p);
  475. }
  476. }
  477. *p = '';
  478. }
  480. /*
  481.  * LATINn ---> MIC
  482.  */
  483. static void
  484. latin2mic(unsigned char *l, unsigned char *p, int len, int lc)
  485. {
  486. int c1;
  488. while (len-- > 0 && (c1 = *l++))
  489. {
  490. if (c1 > 0x7f)
  491. { /* Latin1? */
  492. *p++ = lc;
  493. }
  494. *p++ = c1;
  495. }
  496. *p = '';
  497. }
  499. /*
  500.  * MIC ---> LATINn
  501.  */
  502. static void
  503. mic2latin(unsigned char *mic, unsigned char *p, int len, int lc)
  504. {
  505. int c1;
  507. while (len > 0 && (c1 = *mic))
  508. {
  509. len -= pg_mic_mblen(mic++);
  511. if (c1 == lc)
  512. *p++ = *mic++;
  513. else if (c1 > 0x7f)
  514. {
  515. mic--;
  516. printBogusChar(&mic, &p);
  517. }
  518. else
  519. { /* should be ASCII */
  520. *p++ = c1;
  521. }
  522. }
  523. *p = '';
  524. }
  526. static void
  527. latin12mic(unsigned char *l, unsigned char *p, int len)
  528. {
  529. latin2mic(l, p, len, LC_ISO8859_1);
  530. }
  531. static void
  532. mic2latin1(unsigned char *mic, unsigned char *p, int len)
  533. {
  534. mic2latin(mic, p, len, LC_ISO8859_1);
  535. }
  536. static void
  537. latin22mic(unsigned char *l, unsigned char *p, int len)
  538. {
  539. latin2mic(l, p, len, LC_ISO8859_2);
  540. }
  541. static void
  542. mic2latin2(unsigned char *mic, unsigned char *p, int len)
  543. {
  544. mic2latin(mic, p, len, LC_ISO8859_2);
  545. }
  546. static void
  547. latin32mic(unsigned char *l, unsigned char *p, int len)
  548. {
  549. latin2mic(l, p, len, LC_ISO8859_3);
  550. }
  551. static void
  552. mic2latin3(unsigned char *mic, unsigned char *p, int len)
  553. {
  554. mic2latin(mic, p, len, LC_ISO8859_3);
  555. }
  556. static void
  557. latin42mic(unsigned char *l, unsigned char *p, int len)
  558. {
  559. latin2mic(l, p, len, LC_ISO8859_4);
  560. }
  561. static void
  562. mic2latin4(unsigned char *mic, unsigned char *p, int len)
  563. {
  564. mic2latin(mic, p, len, LC_ISO8859_4);
  565. }
  566. #ifdef NOT_USED
  567. static void
  568. latin52mic(unsigned char *l, unsigned char *p, int len)
  569. {
  570. latin2mic(l, p, len, LC_ISO8859_5);
  571. }
  572. static void
  573. mic2latin5(unsigned char *mic, unsigned char *p, int len)
  574. {
  575. mic2latin(mic, p, len, LC_ISO8859_5);
  576. }
  578. #endif
  580. /*
  581.  * ASCII ---> MIC
  582.  */
  583. static void
  584. ascii2mic(unsigned char *l, unsigned char *p, int len)
  585. {
  586. int c1;
  588. while (len-- > 0 && (c1 = *l++))
  589. *p++ = (c1 & 0x7f);
  590. *p = '';
  591. }
  593. /*
  594.  * MIC ---> ASCII
  595.  */
  596. static void
  597. mic2ascii(unsigned char *mic, unsigned char *p, int len)
  598. {
  599. int c1;
  601. while (len-- > 0 && (c1 = *mic))
  602. {
  603. if (c1 > 0x7f)
  604. printBogusChar(&mic, &p);
  605. else
  606. { /* should be ASCII */
  607. *p++ = c1;
  608. }
  609. mic++;
  610. }
  611. *p = '';
  612. }
  614. /*
  615.  * Cyrillic support
  616.  * currently supported Cyrillic encodings:
  617.  *
  618.  * KOI8-R (this is the charset for the mule internal code
  619.  * for Cyrillic)
  620.  * ISO-8859-5
  621.  * Microsoft's CP1251(windows-1251)
  622.  * Alternativny Variant (MS-DOS CP866)
  623.  */
  625. /* koi2mic: KOI8-R to Mule internal code */
  626. static void
  627. koi2mic(unsigned char *l, unsigned char *p, int len)
  628. {
  629. latin2mic(l, p, len, LC_KOI8_R);
  630. }
  632. /* mic2koi: Mule internal code to KOI8-R */
  633. static void
  634. mic2koi(unsigned char *mic, unsigned char *p, int len)
  635. {
  636. mic2latin(mic, p, len, LC_KOI8_R);
  637. }
  639. /*
  640.  * latin2mic_with_table: a generic single byte charset encoding
  641.  * conversion from a local charset to the mule internal code.
  642.  * with a encoding conversion table.
  643.  * the table is ordered according to the local charset,
  644.  * starting from 128 (0x80). each entry in the table
  645.  * holds the corresponding code point for the mule internal code.
  646.  */
  647. static void
  648. latin2mic_with_table(
  649.  unsigned char *l, /* local charset string (source) */
  650.  unsigned char *p, /* pointer to store mule internal
  651.  * code (destination) */
  652.  int len, /* length of l */
  653.  int lc, /* leading character of p */
  654.  unsigned char *tab /* code conversion table */
  655. )
  656. {
  657. unsigned char c1,
  658. c2;
  660. while (len-- > 0 && (c1 = *l++))
  661. {
  662. if (c1 < 128)
  663. *p++ = c1;
  664. else
  665. {
  666. c2 = tab[c1 - 128];
  667. if (c2)
  668. {
  669. *p++ = lc;
  670. *p++ = c2;
  671. }
  672. else
  673. {
  674. *p++ = ' '; /* cannot convert */
  675. }
  676. }
  677. }
  678. *p = '';
  679. }
  681. /*
  682.  * mic2latin_with_table: a generic single byte charset encoding
  683.  * conversion from the mule internal code to a local charset
  684.  * with a encoding conversion table.
  685.  * the table is ordered according to the second byte of the mule
  686.  * internal code starting from 128 (0x80).
  687.  * each entry in the table
  688.  * holds the corresponding code point for the local code.
  689.  */
  690. static void
  691. mic2latin_with_table(
  692.  unsigned char *mic, /* mule internal code
  693.  * (source) */
  694.  unsigned char *p, /* local code (destination) */
  695.  int len, /* length of p */
  696.  int lc, /* leading character */
  697.  unsigned char *tab /* code conversion table */
  698. )
  699. {
  701. unsigned char c1,
  702. c2;
  704. while (len-- > 0 && (c1 = *mic++))
  705. {
  706. if (c1 < 128)
  707. *p++ = c1;
  708. else if (c1 == lc)
  709. {
  710. c1 = *mic++;
  711. len--;
  712. c2 = tab[c1 - 128];
  713. if (c2)
  714. *p++ = c2;
  715. else
  716. {
  717. *p++ = ' '; /* cannot convert */
  718. }
  719. }
  720. else
  721. {
  722. *p++ = ' '; /* bogus character */
  723. }
  724. }
  725. *p = '';
  726. }
  728. /* iso2mic: ISO-8859-5 to Mule internal code */
  729. static void
  730. iso2mic(unsigned char *l, unsigned char *p, int len)
  731. {
  732. static unsigned char iso2koi[] = {
  733. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  734. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  735. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  736. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  737. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  738. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  739. 0xe1, 0xe2, 0xf7, 0xe7, 0xe4, 0xe5, 0xf6, 0xfa,
  740. 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0,
  741. 0xf2, 0xf3, 0xf4, 0xf5, 0xe6, 0xe8, 0xe3, 0xfe,
  742. 0xfb, 0xfd, 0xff, 0xf9, 0xf8, 0xfc, 0xe0, 0xf1,
  743. 0xc1, 0xc2, 0xd7, 0xc7, 0xc4, 0xc5, 0xd6, 0xda,
  744. 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0,
  745. 0xd2, 0xd3, 0xd4, 0xd5, 0xc6, 0xc8, 0xc3, 0xde,
  746. 0xdb, 0xdd, 0xdf, 0xd9, 0xd8, 0xdc, 0xc0, 0xd1,
  747. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  748. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  749. };
  751. latin2mic_with_table(l, p, len, LC_KOI8_R, iso2koi);
  752. }
  754. /* mic2iso: Mule internal code to ISO8859-5 */
  755. static void
  756. mic2iso(unsigned char *mic, unsigned char *p, int len)
  757. {
  758. static unsigned char koi2iso[] = {
  759. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  760. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  761. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  762. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  763. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  764. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  765. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  766. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  767. 0xee, 0xd0, 0xd1, 0xe6, 0xd4, 0xd5, 0xe4, 0xd3,
  768. 0xe5, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde,
  769. 0xdf, 0xef, 0xe0, 0xe1, 0xe2, 0xe3, 0xd6, 0xd2,
  770. 0xec, 0xeb, 0xd7, 0xe8, 0xed, 0xe9, 0xe7, 0xea,
  771. 0xce, 0xb0, 0xb1, 0xc6, 0xb4, 0xb5, 0xc4, 0xb3,
  772. 0xc5, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe,
  773. 0xbf, 0xcf, 0xc0, 0xc1, 0xc2, 0xc3, 0xb6, 0xb2,
  774. 0xcc, 0xcb, 0xb7, 0xc8, 0xcd, 0xc9, 0xc7, 0xca
  775. };
  777. mic2latin_with_table(mic, p, len, LC_KOI8_R, koi2iso);
  778. }
  780. /* win2mic: CP1251 to Mule internal code */
  781. static void
  782. win2mic(unsigned char *l, unsigned char *p, int len)
  783. {
  784. static unsigned char win2koi[] = {
  785. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  786. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  787. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  788. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  789. 0x00, 0x00, 0x00, 0x00, 0x00, 0xbd, 0x00, 0x00,
  790. 0xb3, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x00, 0xb7,
  791. 0x00, 0x00, 0xb6, 0xa6, 0xad, 0x00, 0x00, 0x00,
  792. 0xa3, 0x00, 0xa4, 0x00, 0x00, 0x00, 0x00, 0xa7,
  793. 0xe1, 0xe2, 0xf7, 0xe7, 0xe4, 0xe5, 0xf6, 0xfa,
  794. 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0,
  795. 0xf2, 0xf3, 0xf4, 0xf5, 0xe6, 0xe8, 0xe3, 0xfe,
  796. 0xfb, 0xfd, 0xff, 0xf9, 0xf8, 0xfc, 0xe0, 0xf1,
  797. 0xc1, 0xc2, 0xd7, 0xc7, 0xc4, 0xc5, 0xd6, 0xda,
  798. 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0,
  799. 0xd2, 0xd3, 0xd4, 0xd5, 0xc6, 0xc8, 0xc3, 0xde,
  800. 0xdb, 0xdd, 0xdf, 0xd9, 0xd8, 0xdc, 0xc0, 0xd1
  801. };
  803. latin2mic_with_table(l, p, len, LC_KOI8_R, win2koi);
  804. }
  806. /* mic2win: Mule internal code to CP1251 */
  807. static void
  808. mic2win(unsigned char *mic, unsigned char *p, int len)
  809. {
  810. static unsigned char koi2win[] = {
  811. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  812. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  813. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  814. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  815. 0x00, 0x00, 0x00, 0xb8, 0xba, 0x00, 0xb3, 0xbf,
  816. 0x00, 0x00, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00,
  817. 0x00, 0x00, 0x00, 0xa8, 0xaa, 0x00, 0xb2, 0xaf,
  818. 0x00, 0x00, 0x00, 0x00, 0x00, 0xa5, 0x00, 0x00,
  819. 0xfe, 0xe0, 0xe1, 0xf6, 0xe4, 0xe5, 0xf4, 0xe3,
  820. 0xf5, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee,
  821. 0xef, 0xff, 0xf0, 0xf1, 0xf2, 0xf3, 0xe6, 0xe2,
  822. 0xfc, 0xfb, 0xe7, 0xf8, 0xfd, 0xf9, 0xf7, 0xfa,
  823. 0xde, 0xc0, 0xc1, 0xd6, 0xc4, 0xc5, 0xd4, 0xc3,
  824. 0xd5, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce,
  825. 0xcf, 0xdf, 0xd0, 0xd1, 0xd2, 0xd3, 0xc6, 0xc2,
  826. 0xdc, 0xdb, 0xc7, 0xd8, 0xdd, 0xd9, 0xd7, 0xda
  827. };
  829. mic2latin_with_table(mic, p, len, LC_KOI8_R, koi2win);
  830. }
  832. /* alt2mic: CP866 to Mule internal code */
  833. static void
  834. alt2mic(unsigned char *l, unsigned char *p, int len)
  835. {
  836. static unsigned char alt2koi[] = {
  837. 0xe1, 0xe2, 0xf7, 0xe7, 0xe4, 0xe5, 0xf6, 0xfa,
  838. 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0,
  839. 0xf2, 0xf3, 0xf4, 0xf5, 0xe6, 0xe8, 0xe3, 0xfe,
  840. 0xfb, 0xfd, 0xff, 0xf9, 0xf8, 0xfc, 0xe0, 0xf1,
  841. 0xc1, 0xc2, 0xd7, 0xc7, 0xc4, 0xc5, 0xd6, 0xda,
  842. 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0,
  843. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  844. 0x00, 0x00, 0x00, 0x00, 0x00, 0xbd, 0x00, 0x00,
  845. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  846. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  847. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  848. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  849. 0xd2, 0xd3, 0xd4, 0xd5, 0xc6, 0xc8, 0xc3, 0xde,
  850. 0xdb, 0xdd, 0xdf, 0xd9, 0xd8, 0xdc, 0xc0, 0xd1,
  851. 0xb3, 0xa3, 0xb4, 0xa4, 0xb7, 0xa7, 0x00, 0x00,
  852. 0xb6, 0xa6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  853. };
  855. latin2mic_with_table(l, p, len, LC_KOI8_R, alt2koi);
  856. }
  858. /* mic2alt: Mule internal code to CP866 */
  859. static void
  860. mic2alt(unsigned char *mic, unsigned char *p, int len)
  861. {
  862. static unsigned char koi2alt[] = {
  863. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  864. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  865. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  866. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  867. 0x00, 0x00, 0x00, 0xf1, 0xf3, 0x00, 0xf9, 0xf5,
  868. 0x00, 0x00, 0x00, 0x00, 0x00, 0xad, 0x00, 0x00,
  869. 0x00, 0x00, 0x00, 0xf0, 0xf2, 0x00, 0xf8, 0xf4,
  870. 0x00, 0x00, 0x00, 0x00, 0x00, 0xbd, 0x00, 0x00,
  871. 0xee, 0xa0, 0xa1, 0xe6, 0xa4, 0xa5, 0xe4, 0xa3,
  872. 0xe5, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae,
  873. 0xaf, 0xef, 0xe0, 0xe1, 0xe2, 0xe3, 0xa6, 0xa2,
  874. 0xec, 0xeb, 0xa7, 0xe8, 0xed, 0xe9, 0xe7, 0xea,
  875. 0x9e, 0x80, 0x81, 0x96, 0x84, 0x85, 0x94, 0x83,
  876. 0x95, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e,
  877. 0x8f, 0x9f, 0x90, 0x91, 0x92, 0x93, 0x86, 0x82,
  878. 0x9c, 0x9b, 0x87, 0x98, 0x9d, 0x99, 0x97, 0x9a
  879. };
  881. mic2latin_with_table(mic, p, len, LC_KOI8_R, koi2alt);
  882. }
  884. /*
  885.  * end of Cyrillic support
  886.  */
  889. /*-----------------------------------------------------------------
  890.  * WIN1250
  891.  * Microsoft's CP1250(windows-1250)
  892.  *-----------------------------------------------------------------*/
  893. static void
  894. win12502mic(unsigned char *l, unsigned char *p, int len)
  895. {
  896. static unsigned char win1250_2_iso88592[] = {
  897. 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
  898. 0x88, 0x89, 0xA9, 0x8B, 0xA6, 0xAB, 0xAE, 0xAC,
  899. 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
  900. 0x98, 0x99, 0xB9, 0x9B, 0xB6, 0xBB, 0xBE, 0xBC,
  901. 0xA0, 0xB7, 0xA2, 0xA3, 0xA4, 0xA1, 0x00, 0xA7,
  902. 0xA8, 0x00, 0xAA, 0x00, 0x00, 0xAD, 0x00, 0xAF,
  903. 0xB0, 0x00, 0xB2, 0xB3, 0xB4, 0x00, 0x00, 0x00,
  904. 0xB8, 0xB1, 0xBA, 0x00, 0xA5, 0xBD, 0xB5, 0xBF,
  905. 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
  906. 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
  907. 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
  908. 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
  909. 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
  910. 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
  911. 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
  912. 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
  913. };
  915. latin2mic_with_table(l, p, len, LC_ISO8859_2, win1250_2_iso88592);
  916. }
  917. static void
  918. mic2win1250(unsigned char *mic, unsigned char *p, int len)
  919. {
  920. static unsigned char iso88592_2_win1250[] = {
  921. 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
  922. 0x88, 0x89, 0x00, 0x8B, 0x00, 0x00, 0x00, 0x00,
  923. 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
  924. 0x98, 0x99, 0x00, 0x9B, 0x00, 0x00, 0x00, 0x00,
  925. 0xA0, 0xA5, 0xA2, 0xA3, 0xA4, 0xBC, 0x8C, 0xA7,
  926. 0xA8, 0x8A, 0xAA, 0x8D, 0x8F, 0xAD, 0x8E, 0xAF,
  927. 0xB0, 0xB9, 0xB2, 0xB3, 0xB4, 0xBE, 0x9C, 0xA1,
  928. 0xB8, 0x9A, 0xBA, 0x9D, 0x9F, 0xBD, 0x9E, 0xBF,
  929. 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
  930. 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
  931. 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
  932. 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
  933. 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
  934. 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
  935. 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
  936. 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
  937. };
  939. mic2latin_with_table(mic, p, len, LC_ISO8859_2, iso88592_2_win1250);
  940. }
  941. /*-----------------------------------------------------------------*/
  943. pg_encoding_conv_tbl pg_conv_tbl[] = {
  944. {SQL_ASCII, "SQL_ASCII", 0, ascii2mic, mic2ascii}, /* SQL/ACII */
  945. {EUC_JP, "EUC_JP", 0, euc_jp2mic, mic2euc_jp}, /* EUC_JP */
  946. {EUC_CN, "EUC_CN", 0, euc_cn2mic, mic2euc_cn}, /* EUC_CN */
  947. {EUC_KR, "EUC_KR", 0, euc_kr2mic, mic2euc_kr}, /* EUC_KR */
  948. {EUC_TW, "EUC_TW", 0, euc_tw2mic, mic2euc_tw}, /* EUC_TW */
  949. {UNICODE, "UNICODE", 0, 0, 0}, /* UNICODE */
  950. {MULE_INTERNAL, "MULE_INTERNAL", 0, 0, 0}, /* MULE_INTERNAL */
  951. {LATIN1, "LATIN1", 0, latin12mic, mic2latin1}, /* ISO 8859 Latin 1 */
  952. {LATIN2, "LATIN2", 0, latin22mic, mic2latin2}, /* ISO 8859 Latin 2 */
  953. {LATIN3, "LATIN3", 0, latin32mic, mic2latin3}, /* ISO 8859 Latin 3 */
  954. {LATIN4, "LATIN4", 0, latin42mic, mic2latin4}, /* ISO 8859 Latin 4 */
  955. {LATIN5, "LATIN5", 0, iso2mic, mic2iso}, /* ISO 8859 Latin 5 */
  956. {KOI8, "KOI8", 0, koi2mic, mic2koi}, /* KOI8-R */
  957. {WIN, "WIN", 0, win2mic, mic2win}, /* CP1251 */
  958. {ALT, "ALT", 0, alt2mic, mic2alt}, /* CP866 */
  959. {SJIS, "SJIS", 1, sjis2mic, mic2sjis}, /* SJIS */
  960. {BIG5, "BIG5", 1, big52mic, mic2big5}, /* Big5 */
  961. {WIN1250, "WIN1250", 1, win12502mic, mic2win1250}, /* WIN 1250 */
  962. {-1, "", 0, 0, 0} /* end mark */
  963. };