UNICODE 转GB2312 纯C语言 映射法

mummy108

RT:
刚好有需求，UFT8的优势在于多国语言默认兼容，用unicode + uft8的方式做数据传输天生不用考虑多国语言问题，这也是一大优势。
不过UFT8传输汉字需要3个byte。大家看着办咯，

最近是刚需，上位机那边就是用的utf8，所以只能在固件内做unicode转gb2312，因为点阵字库是区位码索引的。

1. //使用到的文件有unicode转gb2312的映射表 默认是从gb2312转unicode  所以注释掉的部分是把表反序。
   
2. //不要吐槽我的渣渣排序算法，赶时间的 而且是WIN 慢点就慢点
   
3. 
   
4. 
   
5. #include <stdint.h>
   
6. #include <stdbool.h>
   
7. //#include <windows.h>
   
8. 
   
9. 
   
10. #define MAX_UNI_INDEX  6768
    
11. 
    
12. //uint16_t const table_gb2312_to_unicode[MAX_UNI_INDEX][2];
    
13. //uint16_t const *const p_table_gb2312_to_unicode = &table_gb2312_to_unicode[0][0];
    
14. 
    
15. //uint16_t table_sorted_unicode[MAX_UNI_INDEX];
    
16. //uint16_t table_sorted_gb2312[MAX_UNI_INDEX];
    
17. //uint16_t table_sorted_section_table[MAX_UNI_INDEX];
    
18. 
    
19. #if 0
    
20. uint16_t const sorted_unicode[MAX_UNI_INDEX];
    
21. uint16_t const sorted_gb2312[MAX_UNI_INDEX];
    
22. 
    
23. const uint32_t c_un_sorted_value = 0xFFFFFFFF;
    
24. uint32_t sort_result[MAX_UNI_INDEX];
    
25. 
    
26. void init_sort_result_buffer(void)
    
27. {
    
28.     for (int i = 0; i < MAX_UNI_INDEX; i++){
    
29.         sort_result[i] = c_un_sorted_value;
    
30.     }
    
31. }
    
32. 
    
33. void sort_form_zero_to_end(void)
    
34. {
    
35.     uint16_t current_min_index = 0;
    
36.     uint16_t min_tmp = c_un_sorted_value;
    
37.     for (int i = 0; i < MAX_UNI_INDEX; i++){
    
38.         for (int j = 0; j < MAX_UNI_INDEX; j++){
    
39.             if (sort_result[j] == c_un_sorted_value){
    
40. //                uint16_t tmp = p_table_gb2312_to_unicode[2*j+1];    //sort by gb2312
    
41.                 uint16_t tmp = p_table_gb2312_to_unicode[2*j];        //sort by unicode
    
42.                 if (tmp < min_tmp){
    
43.                     current_min_index = j;
    
44.                     min_tmp = tmp;
    
45.                 }
    
46.             }
    
47.         }
    
48.         sort_result[current_min_index] = i;
    
49.         min_tmp = c_un_sorted_value;
    
50.         current_min_index = 0;
    
51.     }
    
52. }
    
53. 
    
54. 
    
55. void get_group_unicode_gb2312(void)
    
56. {
    
57.     for (int i = 0; i<MAX_UNI_INDEX;i++){
    
58.         for (int j = 0; j < MAX_UNI_INDEX; j++){
    
59.             if (sort_result[j] == i){
    
60.                 uint16_t tmp_gb2312 = p_table_gb2312_to_unicode[2 * j + 1];
    
61. 
    
62.                 uint8_t tmp_h_8 = tmp_gb2312 >> 8;
    
63.                 uint8_t tmp_l_8 = tmp_gb2312 & 0xFF;
    
64. 
    
65.                 //find sort
    
66.                 table_sorted_unicode[i] = p_table_gb2312_to_unicode[2 * j];
    
67.                 table_sorted_gb2312[i] = tmp_gb2312;
    
68.             }
    
69.         }
    
70.     }
    
71. 
    
72. }
    
73. 
    
74. 
    
75. void printf_to_file(void)
    
76. {
    
77.     int file_write = fopen("test.c","w");
    
78. 
    
79. 
    
80.     fprintf(file_write,"uint16_t const sorted_unicode[MAX_UNI_INDEX]]={\r\n");
    
81.     for (int i = 0; i < MAX_UNI_INDEX; i++){
    
82.         fprintf(file_write, "0x%04X,\n", table_sorted_unicode[i]);
    
83.     }
    
84.     fprintf(file_write, "};\n\n");
    
85. 
    
86. 
    
87.     fprintf(file_write, "uint16_t const sorted_gb2312[MAX_UNI_INDEX]]={\r\n");
    
88.     for (int i = 0; i < MAX_UNI_INDEX; i++){
    
89.         fprintf(file_write, "0x%04X,\n", table_sorted_gb2312[i]);
    
90.     }
    
91.     fprintf(file_write, "};\n\n");
    
92.     fclose(file_write);
    
93. }
    
94. 
    
95. #endif
    
96. 
    
97. 
    
98. 
    
99. int quick_find(uint16_t const * p_data, uint16_t unicode, int min, int max)
    
100. {
     
101.     const int max_serch_cnt_ctrl = 15;
     
102.     int ret = -2;
     
103.     int mid;
     
104.     int i;
     
105.     uint16_t cmp_min;
     
106.     uint16_t cmp_max;
     
107.     uint16_t cmp_mid;
     
108. 
     
109. 
     
110.     for (i = 0; i < max_serch_cnt_ctrl; i++){
     
111.         cmp_min = p_data[min];
     
112.         cmp_max = p_data[max];
     
113. 
     
114.         if (cmp_max == unicode){
     
115.             ret = max;
     
116.             break;
     
117.         }
     
118.         else if (cmp_min == unicode){
     
119. 
     
120.             ret = min;
     
121.             break;
     
122.         }
     
123.         else if (max == min + 1){
     
124.             break;
     
125.             //return -1;
     
126.         }
     
127. 
     
128.         mid = (max + min) / 2;
     
129. 
     
130.         cmp_mid = p_data[mid];
     
131. 
     
132. 
     
133.         if (unicode > cmp_mid){
     
134.             min = mid;
     
135.             continue;
     
136.             //return quick_find(p_data, unicode, mid, max);
     
137.         }
     
138.         else{
     
139.             max = mid;
     
140.             continue;
     
141.             //return quick_find(p_data, unicode, min, mid);
     
142.         }
     
143.     }
     
144. 
     
145.     return ret;
     
146. }
     
147. 
     
148. 
     
149. uint16_t const sorted_unicode[MAX_UNI_INDEX];
     
150. uint16_t const sorted_gb2312[MAX_UNI_INDEX];
     
151. 
     
152. uint8_t buffer[32];
     
153. 
     
154. 
     
155. void print_lib_font(uint8_t* pData)
     
156. {
     
157.     for (int i = 0; i<16;i++){
     
158.         for (int j = 0; j < 2; j++){
     
159.             for (int k = 0; k<8; k++){
     
160.                 uint8_t bit_fix = 0x80 >> k;
     
161.                 int tmp = pData[i*2 + j] & bit_fix;
     
162. 
     
163.                 if (tmp){
     
164.                     printf("#");
     
165.                 }
     
166.                 else{
     
167.                     printf("-");
     
168.                 }
     
169.             }
     
170.         }
     
171.         printf("\n");
     
172.     }
     
173. }
     
174. 
     
175. void test_lib(void)
     
176. {
     
177.     int fp;
     
178. //    uint16_t test_1 = 0x3158;    //口
     
179. 
     
180.     uint16_t unicode = 0x68EE;    //UNICODE OF "森"
     
181.     char c[] = "一";
     
182. 
     
183. 
     
184.     int result = quick_find(sorted_unicode, unicode, 0, MAX_UNI_INDEX);
     
185. 
     
186.     uint16_t gb2312 = sorted_gb2312[result];
     
187. 
     
188.     c[0] = gb2312 >> 8;
     
189.     c[1] = gb2312 & 0xFF;
     
190. 
     
191.     uint8_t h = c[0] - 0xA0;
     
192.     uint8_t l = c[1] - 0xA0;
     
193. 
     
194.     int t_1 = ((h - 1) * 94 + (l - 1)) * 32;
     
195. 
     
196. //    t_1 = 32;
     
197. 
     
198.     fp = fopen("HZK16", "rb");
     
199. 
     
200.     fseek(fp, t_1, 0);
     
201. 
     
202.     fread(buffer, 32, 1, fp);
     
203.     fclose(fp);
     
204. 
     
205.     print_lib_font(buffer);
     
206. }
     
207. 
     
208. int main(int char_c, char** char_v)
     
209. {
     
210. 
     
211.     //init_sort_result_buffer();
     
212. 
     
213.     //sort_form_zero_to_end();
     
214. 
     
215.     //get_group_unicode_gb2312();
     
216. 
     
217.     //printf_to_file();
     
218. 
     
219.     //{ 0x7F36, 0xF3BE },//GB2312:缶
     
220. 
     
221. //    int resule = quick_find(table_sorted_unicode, 0x7F36, 0, MAX_UNI_INDEX - 1);
     
222. 
     
223. //    printf("\nfind_gb2312_is:0x%04X\nshould be equal to 0xF3BE", table_sorted_gb2312[resule]);
     
224. 
     
225. //    printf("缶 is  %x","缶");
     
226. 
     
227.     test_lib();
     
228. 
     
229. 
     
230. //    system("pause");
     
231. 
     
232.     return 0;
     
233. }

复制代码

上传的都是验证性的代码，有需要的自行提取了，附件里面是提取好的映射表和HZK16的点阵字库

mummy108

贴的代码里面数组内容是空的，因为这几个数组很大==!  有需要在附件里面可以看，我的环境是VS2013,实际用任何C的环境应该都是可以运行的

xiaoyigechaos

刚好需要               

山在桥那边

为什么是纯映射 没规律么

mummy108

山在桥那边 发表于 2014-11-17 15:42
为什么是纯映射 没规律么

因为UNICODE 跟GB2312是两个完全不同的组织做出来的编码，具体细节自己去查了，我只能说我这个办法可以实现，然后需要大约17K的readonly空间

mummy108

xiaoyigechaos 发表于 2014-11-17 12:10
刚好需要

我也是找半天找不到.. 就自己折腾了，分享出来不要重复造轮子呗

gushuailove

有用，我这边用的是反过来的。

mummy108

gushuailove 发表于 2014-11-17 20:33
有用，我这边用的是反过来的。

嗯，我找到的资源就是按gb2312排序好的，不过我的需求是UNICODE 转gb2312 我就给翻转了

阿文

谢谢分享

not_at_all

mummy108 发表于 2014-11-17 20:53
嗯，我找到的资源就是按gb2312排序好的，不过我的需求是UNICODE 转gb2312 我就给翻转了  ...

可以看看ELM的 FATFS 源代码，里面有，通过二分法查表实现

mummy108

not_at_all 发表于 2014-11-17 21:26
可以看看ELM的 FATFS 源代码，里面有，通过二分法查表实现

嗯，都是查表二分的话 应该差不多... 就是不好找.. 而且个人不喜欢二维数组..

not_at_all

mummy108 发表于 2014-11-17 21:34
嗯，都是查表二分的话 应该差不多... 就是不好找.. 而且个人不喜欢二维数组..  ...

都是一维数组啊

mummy108

not_at_all 发表于 2014-11-17 21:51
都是一维数组啊

啊 好吧  我没找到资源... 不过性能上应该差不了多少，而且开源也用二分查表，就说明这个转换还只有二分搞得定 是吧。。。

dgtg

mark!!!用到GB2312转UNICODE

机器人天空

还没弄过，学习了

not_at_all

mummy108 发表于 2014-11-17 22:01
啊  好吧  我没找到资源... 不过性能上应该差不了多少，而且开源也用二分查表，就说明这个转 ...

对于常规应用，用二分法查表不但效率高，而且程序比较简洁，所以比较通用

qiushui_007

了解下实现的思路

ye_song

java与c通信时需要