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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机WAP编程 > 查看源码
charset.c
资源名称：gateway-1.2.1　[点击查看]
上传用户：gzpyjq
上传日期：2013-01-31
资源大小：1852k
文件大小：12k
源码类别：

手机WAP编程

开发平台：

WINDOWS

charset.c：源码内容
  1. /*
  2.  * gwlib/charset.c - character set conversions
  3.  *
  4.  * This file implements the character set conversions declared in charset.h.
  5.  *
  6.  * Richard Braakman
  7.  */
  9. #include "gwlib/gwlib.h"
  11. /* Map GSM default alphabet characters to ISO-Latin-1 characters.
  12.  * The greek characters at positions 16 and 18 through 26 are not
  13.  * mappable.  They are mapped to '?' characters.
  14.  * The escape character, at position 27, is mapped to a space,
  15.  * though normally the function that indexes into this table will
  16.  * treat it specially. */
  17. static const unsigned char gsm_to_latin1[128] = {
  18.  '@', 0xa3,  '$', 0xa5, 0xe8, 0xe9, 0xf9, 0xec,   /* 0 - 7 */
  19. 0xf2, 0xc7,   10, 0xd8, 0xf8,   13, 0xc5, 0xe5,   /* 8 - 15 */
  20.  '?',  '_',  '?',  '?',  '?',  '?',  '?',  '?',   /* 16 - 23 */
  21.          '?',  '?',  '?',  ' ', 0xc6, 0xe6, 0xdf, 0xc9,   /* 24 - 31 */
  22.  ' ',  '!',  '"',  '#', 0xa4,  '%',  '&', ''',   /* 32 - 39 */
  23.  '(',  ')',  '*',  '+',  ',',  '-',  '.',  '/',   /* 40 - 47 */
  24.  '0',  '1',  '2',  '3',  '4',  '5',  '6',  '7',   /* 48 - 55 */
  25.  '8',  '9',  ':',  ';',  '<',  '=',  '>',  '?',   /* 56 - 63 */
  26.         0xa1,  'A',  'B',  'C',  'D',  'E',  'F',  'G',   /* 64 - 71 */
  27.          'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',   /* 73 - 79 */
  28.          'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',   /* 80 - 87 */
  29.          'X',  'Y',  'Z', 0xc4, 0xd6, 0xd1, 0xdc, 0xa7,   /* 88 - 95 */
  30.         0xbf,  'a',  'b',  'c',  'd',  'e',  'f',  'g',   /* 96 - 103 */
  31.          'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',   /* 104 - 111 */
  32.          'p',  'q',  'r',  's',  't',  'u',  'v',  'w',   /* 112 - 119 */
  33.          'x',  'y',  'z', 0xe4, 0xf6, 0xf1, 0xfc, 0xe0    /* 120 - 127 */
  34. };
  36. /* This is the extension table defined in GSM 03.38.  It is the mapping
  37.  * used for the character after a GSM 27 (Escape) character.  All characters
  38.  * not in the table, as well as characters we can't represent, will map
  39.  * to themselves.  We cannot represent the euro symbol, which is an escaped
  40.  * 'e', so we left it out of this table. */
  41. static const struct {
  42. int gsmesc;
  43. int latin1;
  44. } gsm_escapes[] = {
  45. {  10, 12 }, /* ASCII page break */
  46. {  20, '^' },
  47. {  40, '{' },
  48. {  41, '}' },
  49. {  47, '\' },
  50. {  60, '[' },
  51. {  61, '~' },
  52. {  62, ']' },
  53. {  64, '|' },
  54. { 101, 128 },
  55. { -1, -1 }
  56. };
  58. /* Code used for non-representable characters */
  59. #define NRP '?'
  61. /* Map ISO-Latin-1 characters to the GSM default alphabet.  Negative
  62.  * encoded as ESC (code 27) followed by the absolute value of the
  63.  * number. */
  64. static const int latin1_to_gsm[256] = {
  65. NRP, NRP, NRP, NRP, NRP, NRP, NRP, NRP,       /* 0 - 7 */
  66. /* TAB approximates to space */
  67. /* LF and CR map to self */
  68. /* Page break maps to escaped LF */
  69. NRP, ' ',  10, NRP, -10,  13, NRP, NRP,       /* 8 - 15 */
  70. /* 16, 18-26 are nonprintable in latin1, and in GSM are greek
  71.  * characters that are unrepresentable in latin1.  So we let them
  72.  * map to self, to create a way to specify them. */
  73.  16, NRP,  18,  19,  20,  21,  22,  23,       /* 16 - 23 */
  74.  24,  25,  26, NRP, NRP, NRP, NRP, NRP,       /* 24 - 31 */
  75. /* $ maps to 2 */
  76. ' ', '!', '"', '#',   2, '%', '&', ''',      /* 32 - 39 */
  77. '(', ')', '*', '+', ',', '-', '.', '/',       /* 40 - 47 */
  78. '0', '1', '2', '3', '4', '5', '6', '7',       /* 48 - 55 */
  79. '8', '9', ':', ';', '<', '=', '>', '?',       /* 56 - 63 */
  80. /* @ maps to 0 */
  81.   0, 'A', 'B', 'C', 'D', 'E', 'F', 'G',       /* 64 - 71 */
  82. 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',       /* 72 - 79 */
  83. 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',       /* 80 - 87 */
  84. /* [ is an escaped < */
  85. /*  is an escaped / */
  86. /* ] is an escaped > */
  87. /* ^ is an escaped Greek Lambda */
  88. /* _ maps to 17 */
  89. 'X', 'Y', 'Z', -60, -47, -62, -20,  17,       /* 88 - 95 */
  90. /* The backquote cannot be represented at all */
  91. NRP, 'a', 'b', 'c', 'd', 'e', 'f', 'g',       /* 96 - 103 */
  92. 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',       /* 104 - 111 */
  93. 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',       /* 112 - 119 */
  94. /* { is an escaped ( */
  95. /* | is an escaped inverted ! */
  96. /* } is an escaped ) */
  97. /* ~ is an escaped = */
  98. 'x', 'y', 'z', -40, -64, -41, -61, NRP,       /* 120 - 127 */
  99. -101, NRP, NRP, NRP, NRP, NRP, NRP, NRP,       /* 128 - 135 */
  100. NRP, NRP, NRP, NRP, NRP, NRP, NRP, NRP,       /* 136 - 143 */
  101. NRP, NRP, NRP, NRP, NRP, NRP, NRP, NRP,       /* 144 - 151 */
  102. NRP, NRP, NRP, NRP, NRP, NRP, NRP, NRP,       /* 152 - 159 */
  104. /* 160 - 167 */
  105. ' ',
  106.  64, /* Inverted ! */
  107. 'c', /* approximation of cent marker */
  108.   1, /* Pounds sterling */
  109.  36, /* International currency symbol */
  110.   3, /* Yen */
  111.  64, /* approximate broken bar as inverted ! */
  112.  95, /* Section marker */
  114. /* 168 - 175 */
  115. '"', /* approximate dieresis */
  116. 'C', /* approximate copyright marker */
  117. 'a', /* approximate ordfeminine */
  118. '<', /* approximate french << */
  119. '!', /* approximate logical not sign */
  120. '-', /* approximate hyphen */
  121. 'R', /* approximate registered marker */
  122. '-', /* approximate macron */
  124. /* 176 - 183 */
  125. 'o', /* approximate degree marker */
  126. NRP, /* plusminus */
  127. '2', /* approximate superscript 2 */
  128. '3', /* approximate superscript 3 */
  129. ''', /* approximate acute accent */
  130. 'u', /* approximate greek mu */
  131. NRP, /* paragraph marker */
  132. '.', /* approximate bullet */
  134. /* 184 - 191 */
  135. ',', /* approximate cedilla */
  136. 'i', /* approximate dotless i */
  137. 'o', /* approximate ordmasculine */
  138. '>', /* approximate french >> */
  139. NRP, /* onequarter */
  140. NRP, /* onehalf */
  141. NRP, /* threequarters */
  142.  96, /* Inverted ? */
  144. /* 192 - 199 */
  145. 'A', /* approximate A grave */
  146. 'A', /* approximate A acute */
  147. 'A', /* approximate A circumflex */
  148. 'A', /* approximate A tilde */
  149.  91, /* A dieresis */
  150.  14, /* A ring */
  151.  28, /* AE ligature */
  152.   9, /* C cedilla */
  154. /* 200 - 207 */
  155. 'E', /* approximate E grave */
  156.  31, /* E acute */
  157. 'E', /* approximate E circumflex */
  158. 'E', /* approximate E dieresis */
  159. 'I', /* approximate I grave */
  160. 'I', /* approximate I acute */
  161. 'I', /* approximate I circumflex */
  162. 'I', /* approximate I dieresis */
  164. /* 208 - 215 */
  165. NRP, /* Eth */
  166.  93, /* N tilde */
  167. 'O', /* approximate O grave */
  168. 'O', /* approximate O acute */
  169. 'O', /* approximate O circumflex */
  170. 'O', /* approximate O tilde */
  171.  92, /* O dieresis */
  172. 'x', /* approximate multiplication sign */
  174. /* 216 - 223 */
  175.  11, /* O slash */
  176. 'U', /* approximate U grave */
  177. 'U', /* approximate U acute */
  178. 'U', /* approximate U circumflex */
  179.  94, /* U dieresis */
  180. 'Y', /* approximate Y acute */
  181. NRP, /* approximate Thorn */
  182.  30, /* german double-s */
  184. /* 224 - 231 */
  185. 127, /* a grave */
  186. 'a', /* approximate a acute */
  187. 'a', /* approximate a circumflex */
  188. 'a', /* approximate a tilde */
  189. 123, /* a dieresis */
  190.  15, /* a ring */
  191.  29, /* ae ligature */
  192. 'c', /* approximate c cedilla as c */
  194. /* 232 - 239 */
  195.   4, /* e grave */
  196.   5, /* e acute */
  197. 'e', /* approximate e circumflex */
  198. 'e', /* approximate e dieresis */
  199.   7, /* i grave */
  200. 'i', /* approximate i acute */
  201. 'i', /* approximate i circumflex */
  202. 'i', /* approximate i dieresis */
  204. /* 240 - 247 */
  205. NRP, /* eth */
  206. 125, /* n tilde */
  207.   8, /* o grave */
  208. 'o', /* approximate o acute */
  209. 'o', /* approximate o circumflex */
  210. 'o', /* approximate o tilde */
  211. 124, /* o dieresis */
  212. NRP, /* division sign */
  214. /* 248 - 255 */
  215.  12, /* o slash */
  216.   6, /* u grave */
  217. 'u', /* approximate u acute */
  218. 'u', /* approximate u circumflex */
  219. 126, /* u dieresis */
  220. 'y', /* approximate y acute */
  221. NRP, /* thorn */
  222. 'y', /* approximate y dieresis */
  223. };
  225. /*
  226.  * Register alises for Windows character sets that the libxml/libiconv can 
  227.  * recoqnise them.
  228.  */
  230. struct alias_t {
  231.     char *real;
  232.     char *alias;
  233. }; 
  235. typedef struct alias_t alias_t;
  237. alias_t chars_aliases[] = {
  238.     { "CP1250", "WIN-1250" }, 
  239.     { "CP1250", "WINDOWS-1250" },
  240.     { "CP1251", "WIN-1251" }, 
  241.     { "CP1251", "WINDOWS-1251" },
  242.     { "CP1252", "WIN-1252" }, 
  243.     { "CP1252", "WINDOWS-1252" },
  244.     { "CP1253", "WIN-1253" }, 
  245.     { "CP1253", "WINDOWS-1253" },
  246.     { "CP1254", "WIN-1254" }, 
  247.     { "CP1254", "WINDOWS-1254" },
  248.     { "CP1257", "WIN-1257" },
  249.     { "CP1257", "WINDOWS-1257" },
  250.     { NULL }
  251. };
  253. void charset_init()
  254. {
  255.     int i;
  257.     for (i = 0; chars_aliases[i].real != NULL; i++) {
  258.       xmlAddEncodingAlias(chars_aliases[i].real,chars_aliases[i].alias);
  259.       /*debug("encoding",0,"Add encoding for %s",chars_aliases[i].alias);*/
  260.     }
  261. }
  263. void charset_shutdown()
  264. {
  265.     xmlCleanupEncodingAliases();
  266. }
  269. void charset_gsm_to_latin1(Octstr *ostr)
  270. {
  271.     long pos, len;
  273.     len = octstr_len(ostr);
  274.     for (pos = 0; pos < len; pos++) {
  275. int c, new, i;
  277. c = octstr_get_char(ostr, pos);
  278. if (c == 27 && pos + 1 < len) {
  279.     /* GSM escape code.  Delete it, then process the next
  280.              * character specially. */
  281.     octstr_delete(ostr, pos, 1);
  282.     len--;
  283.     c = octstr_get_char(ostr, pos);
  284.     for (i = 0; gsm_escapes[i].gsmesc >= 0; i++) {
  285. if (gsm_escapes[i].gsmesc == c)
  286.        break;
  287.     }
  288.     if (gsm_escapes[i].gsmesc == c)
  289. new = gsm_escapes[i].latin1;
  290.     else if (c < 128)
  291. new = gsm_to_latin1[c];
  292.     else
  293. continue;
  294. } else if (c < 128) {
  295.             new = gsm_to_latin1[c];
  296. } else {
  297.     continue;
  298. }
  299. if (new != c)
  300.     octstr_set_char(ostr, pos, new);
  301.     }
  302. }
  304. void charset_latin1_to_gsm(Octstr *ostr)
  305. {
  306.     long pos, len;
  307.     int c, new;
  308.     unsigned char esc = 27;
  310.     len = octstr_len(ostr);
  311.     for (pos = 0; pos < len; pos++) {
  312. c = octstr_get_char(ostr, pos);
  313. gw_assert(c >= 0);
  314. gw_assert(c <= 256);
  315. new = latin1_to_gsm[c];
  316. if (new < 0) {
  317.          /* Escaped GSM code */
  318.     octstr_insert_data(ostr, pos, &esc, 1);
  319.     pos++;
  320.     len++;
  321.     new = -new;
  322. }
  323. if (new != c)
  324.     octstr_set_char(ostr, pos, new);
  325.     }
  326. }
  328. int charset_gsm_truncate(Octstr *gsm, long max)
  329. {
  330.     if (octstr_len(gsm) > max) {
  331. /* If the last GSM character was an escaped character,
  332.  * then chop off the escape as well as the character. */
  333. if (octstr_get_char(gsm, max - 1) == 27)
  334.        octstr_truncate(gsm, max - 1);
  335. else
  336.     octstr_truncate(gsm, max);
  337. return 1;
  338.     }
  339.     return 0;
  340. }
  342. int charset_to_utf8(Octstr *from, Octstr **to, Octstr *charset_from)
  343. {
  344.     int ret;
  345.     xmlCharEncodingHandlerPtr handler = NULL;
  346.     xmlBufferPtr frombuffer = NULL;
  347.     xmlBufferPtr tobuffer = NULL;
  349.     if (octstr_compare(charset_from, octstr_imm("UTF-8")) == 0) {
  350.         *to = octstr_duplicate(from);
  351.         return 0;
  352.     }
  354.     handler = xmlFindCharEncodingHandler(octstr_get_cstr(charset_from));
  355.     if (handler == NULL)
  356. return -2;
  358.     /* Build the libxml buffers for the transcoding. */
  359.     tobuffer = xmlBufferCreate();
  360.     frombuffer = xmlBufferCreate();
  361.     xmlBufferAdd(frombuffer, octstr_get_cstr(from), octstr_len(from));
  363.     ret = xmlCharEncInFunc(handler, tobuffer, frombuffer);
  365.     *to = octstr_create_from_data(tobuffer->content, tobuffer->use);
  367.     /* Memory cleanup. */
  368.     xmlBufferFree(tobuffer);
  369.     xmlBufferFree(frombuffer);
  371.     return ret;
  372. }
  374. int charset_from_utf8(Octstr *utf8, Octstr **to, Octstr *charset_to)
  375. {
  376.     int ret;
  377.     xmlCharEncodingHandlerPtr handler = NULL;
  378.     xmlBufferPtr frombuffer = NULL;
  379.     xmlBufferPtr tobuffer = NULL;
  381.     handler = xmlFindCharEncodingHandler(octstr_get_cstr(charset_to));
  382.     if (handler == NULL)
  383. return -2;
  385.     /* Build the libxml buffers for the transcoding. */
  386.     tobuffer = xmlBufferCreate();
  387.     frombuffer = xmlBufferCreate();
  388.     xmlBufferAdd(frombuffer, octstr_get_cstr(utf8), octstr_len(utf8));
  390.     ret = xmlCharEncOutFunc(handler, tobuffer, frombuffer);
  391.     if (ret < -2)
  392. /* Libxml seems to be here a little uncertain what would be the 
  393.  * return code -3, so let's make it -1. Ugly thing, indeed. --tuo */
  394. ret = -1; 
  396.     *to = octstr_create_from_data(tobuffer->content, tobuffer->use);
  398.     /* Memory cleanup. */
  399.     xmlBufferFree(tobuffer);
  400.     xmlBufferFree(frombuffer);
  402.     return ret;
  403. }