跨平台的命令行字典外壳 dic.exe

happy886rr

下载：城通网盘https://page37.ctfile.com/fs/14274637-204821002

DIC.EXE是一款字典外壳第三方，已做多平台延伸，代码支持多平台编译，可在windows、linux、安卓、ios等多种设备上运行。查词核心采用自主研发的RODB内存数据库，迄今为止最快的查询速度，查询任何单词耗时都小于1毫秒。RODB意在通过最简短的代码实现最高速的数据查询。
（图片均为外链）（MFC版） 5KB
链接: https://pan.baidu.com/s/10vFlaopRogWbFl4xozOMtA?pwd=i3ij

（安卓版）下载地址：https://page37.ctfile.com/fs/14274637-204820983

跨平台源码：

1. /*
   
2.         CONSOLE ENGLISH-CHINESE DICTIONARY, COPYRIGHT@2017~2019 BY LEO, VERSION 1.0
   
3.         DIC.EXE
   
4. */
   
5. 
   
6. #include   <stdio.h>
   
7. #include  <stdlib.h>
   
8. #include  <string.h>
   
9. #include    <time.h>
   
10. 
    
11. #if !defined(_MSC_VER) && !defined(bool)
    
12. #include <stdbool.h>
    
13. #endif
    
14. 
    
15. /***************定义宏变量***************/
    
16. //标准行长
    
17. #define BUFF_SIZE 1024
    
18. 
    
19. //标准基长
    
20. #define UINT_SIZE 4
    
21. 
    
22. //索引阈值
    
23. #define INDX_SIZE 255*255*UINT_SIZE*4
    
24. 
    
25. /***************定义宏函数***************/
    
26. //字符串转索引值
    
27. #define CHARARRAY2UINT(x) (unsigned int)(((unsigned char)(x)[0]<<24)|((unsigned char)(x)[1]<<16)|((unsigned char)(x)[2]<<8)|((unsigned char)(x)[3]))
    
28. 
    
29. //索引值转字符串
    
30. #define UINT2CHARARRAY(inSTAINER,uINNUM) \
    
31.         (inSTAINER)[0] = (char)(((uINNUM)&0xFF000000)>>24),\
    
32.         (inSTAINER)[1] = (char)(((uINNUM)&0x00FF0000)>>16),\
    
33.         (inSTAINER)[2] = (char)(((uINNUM)&0x0000FF00)>> 8),\
    
34.         (inSTAINER)[3] = (char)( (uINNUM)&0x000000FF     );
    
35. 
    
36. /***************设全局变量***************/
    
37. //微型容器
    
38. char          Keyic[UINT_SIZE];
    
39. unsigned char Brray[UINT_SIZE * 4];
    
40. 
    
41. //行存容器
    
42. char Input[BUFF_SIZE];
    
43. char Line [BUFF_SIZE];
    
44. char lineCACHE[BUFF_SIZE*16];
    
45. 
    
46. //定义RODB数据类型
    
47. typedef struct
    
48. {
    
49.         const char* data;
    
50.         const char* index;
    
51.         const unsigned int indexnum;
    
52. } RODB, *PRODB;
    
53. 
    
54. /***************WIN32兼容 ***************/
    
55. #if defined(WIN32) || defined(__WIN32__)
    
56. 
    
57. //引入WIN32头文件
    
58. #include <windows.h>
    
59. #include  <locale.h>
    
60. 
    
61. //缓存容器
    
62. wchar_t wcsCACHE[BUFF_SIZE * 32];
    
63. char    outCACHE[BUFF_SIZE * 32];
    
64. 
    
65. //ANSI、UTF8互转函数
    
66. char* ANSIteUTF8(const char* inputSTR, int inPAGE, int outPAGE, wchar_t* wcsCACHE, char* outCACHE)
    
67. {
    
68.         //输入代码页 过渡到 UNICODE中转代码页
    
69.         int wlEN=MultiByteToWideChar(inPAGE, 0, inputSTR,-1, NULL, 0);
    
70.         MultiByteToWideChar(inPAGE, 0, inputSTR, -1, wcsCACHE, wlEN);
    
71.         wcsCACHE[wlEN]=L'\0';
    
72. 
    
73.         //UNICODE中转代码页 过渡到 输出代码页
    
74.         int uLEN=WideCharToMultiByte(outPAGE, 0, wcsCACHE, -1, NULL, 0, NULL, NULL);
    
75.         WideCharToMultiByte(outPAGE, 0, wcsCACHE, -1, outCACHE, uLEN, NULL, NULL);
    
76.         outCACHE[uLEN]='\0';
    
77. 
    
78.         //返回结果
    
79.         return outCACHE;
    
80. }
    
81. #endif
    
82. 
    
83. /***************功能函数群***************/
    
84. //快排回调
    
85. int CompUINT(const void* a, const void* b)
    
86. {
    
87.         unsigned int leftINDEX=CHARARRAY2UINT((unsigned char*)a), rightINDEX=CHARARRAY2UINT((unsigned char*)b);
    
88.        
    
89.         //布尔比较 化解 UINT溢出漏洞
    
90.         if(leftINDEX <rightINDEX)
    
91.         {
    
92.                 return -1;
    
93.         }
    
94.         return (int)(leftINDEX >rightINDEX);
    
95. }
    
96. 
    
97. //创建 RODB 内存数据库
    
98. RODB CreatRODB(const char* dicDATA_FILE, const char demilCHAR, unsigned char* pBRRAY)
    
99. {
    
100.         //读取字典文件
     
101.         FILE* fp=fopen(dicDATA_FILE, "rb");
     
102.         if(fp == NULL)
     
103.         {
     
104.                 fprintf(stdout, "[ERROR]: read dictionary error\n");
     
105.                 exit(1);
     
106.         }
     
107. 
     
108.         //获取字典文件尺寸
     
109.         fseek(fp, 0, SEEK_END);
     
110.         int fsize= ftell(fp);
     
111.         fseek(fp, 0, SEEK_SET);
     
112. 
     
113.         //动态分配字典容器
     
114.         char* dicDATA=(char*)malloc(fsize+2);
     
115. 
     
116.         //将字典文件读入内存
     
117.         fread(dicDATA, sizeof(char), fsize, fp);
     
118.         fclose(fp);
     
119.         dicDATA[fsize]='\n', dicDATA[fsize+1]='\0';
     
120. 
     
121.         //动态分配索引容器
     
122.         char* fastINDEX=(char*)malloc(INDX_SIZE), *fastp=fastINDEX;
     
123. 
     
124.         int lpHEAD, indexCOUNT=0, preINDEX_OFFSET=0, perINDEX_OFFLEN=0;
     
125.         unsigned int preINDEX=(unsigned int)0, curINDEX=(unsigned int)0;
     
126. 
     
127.         bool needsQSORT=false;
     
128.         char* lp=NULL, *cp=(char*)dicDATA;
     
129.         while(*cp != '\0')
     
130.         {
     
131.                 lpHEAD=(int)(char*)cp, lp=(char*)Line;
     
132. 
     
133.                 //读取关键词KEY：分隔符前字串
     
134.                 while((*cp != '\n') && (*cp != demilCHAR))
     
135.                 {
     
136.                         *lp++ = *cp++;
     
137.                 };
     
138.                 *lp='\0';
     
139. 
     
140.                 //数据指针 置 流位 换行符
     
141.                 while(*cp++ != '\n');
     
142. 
     
143.                 //提取 关键词KEY 前4字符
     
144.                 strncpy((char*)pBRRAY, Line, UINT_SIZE);
     
145. 
     
146.                 //根据 KEY前4字符 创建索引
     
147.                 curINDEX=CHARARRAY2UINT(pBRRAY);
     
148. 
     
149.                 //效验索引可行性
     
150.                 if(curINDEX < preINDEX)
     
151.                 {
     
152.                         //如果逆序，则启用QSORT快排
     
153.                         needsQSORT=true;
     
154.                 }
     
155. 
     
156.                 //比对索引
     
157.                 if(curINDEX != preINDEX)
     
158.                 {
     
159.                         //打印索引值
     
160.                         //fprintf(stdout, "%u %s\n", curINDEX, Line);
     
161. 
     
162.                         int ILEN=lpHEAD-preINDEX_OFFSET, IOFFSET=lpHEAD-(int)(char*)dicDATA;
     
163.                         if(fastp != fastINDEX)
     
164.                         {
     
165.                                 //尺度码块
     
166.                                 UINT2CHARARRAY(fastp, (unsigned int)ILEN);
     
167.                                 fastp+=4;
     
168.                         }
     
169. 
     
170.                         //索引码块
     
171.                         UINT2CHARARRAY(fastp, (unsigned int)curINDEX);
     
172.                         indexCOUNT++;
     
173.                         fastp+=4;
     
174. 
     
175.                         //效验码块
     
176.                         UINT2CHARARRAY(fastp, (unsigned int)0);
     
177.                         fastp+=4;
     
178. 
     
179.                         //偏移码块
     
180.                         UINT2CHARARRAY(fastp, (unsigned int)IOFFSET);
     
181.                         fastp+=4;
     
182. 
     
183.                         preINDEX=curINDEX;
     
184.                         preINDEX_OFFSET=lpHEAD;
     
185.                 }
     
186.         }
     
187. 
     
188.         int lastOFFSET=(int)(char*)dicDATA+fsize-preINDEX_OFFSET;
     
189. 
     
190.         if(fastp != fastINDEX)
     
191.         {
     
192.                 //追加结尾尺度码块
     
193.                 UINT2CHARARRAY(fastp, (unsigned int)lastOFFSET);
     
194.                 fastp+=4;
     
195.         }
     
196. 
     
197.         //置结束符
     
198.         *fastp='\0';
     
199. 
     
200.         //启用快排索引
     
201.         if(needsQSORT)
     
202.         {
     
203.                 qsort((void*)fastINDEX, (size_t)indexCOUNT, (size_t)UINT_SIZE * 4, CompUINT);
     
204.         }
     
205. 
     
206.         RODB ret = {(const char*)dicDATA, (const char*)fastINDEX, (const unsigned int)indexCOUNT};
     
207. 
     
208.         //返回RODB指针
     
209.         return ret;
     
210. }
     
211. 
     
212. //高速查询核心
     
213. bool SearchResultCharArray(PRODB prodb, unsigned int uSEARCH_INDEX, unsigned char* pBRRAY, char* lineCACHE, char* Line, char* srcKEY)
     
214. {
     
215.         //使用闭区间
     
216.         int i, minIDX = -1, maxIDX = (unsigned int)(prodb->indexnum);
     
217.         unsigned iSEARCH_INDEX;
     
218.         bool bret=false;
     
219. 
     
220.         while(maxIDX - minIDX > 1)
     
221.         {
     
222.                 i = (maxIDX + minIDX)>>1;
     
223. 
     
224.                 //读取字典索引值
     
225.                 memcpy(pBRRAY, &((prodb->index)[UINT_SIZE * 4 * i]), UINT_SIZE * 4);
     
226.                 iSEARCH_INDEX = CHARARRAY2UINT(pBRRAY);
     
227. 
     
228.                 //找到目标索引
     
229.                 if(iSEARCH_INDEX == uSEARCH_INDEX)
     
230.                 {
     
231.                         break;
     
232.                 }
     
233. 
     
234.                 //更新搜索范围
     
235.                 (iSEARCH_INDEX  < uSEARCH_INDEX) ?(minIDX = i) :(maxIDX = i);
     
236.         }
     
237. 
     
238.         //如果搜索不到，则退出
     
239.         if(iSEARCH_INDEX != uSEARCH_INDEX)
     
240.         {
     
241.                 //查询失败
     
242.                 return bret;
     
243.         }
     
244. 
     
245.         //获取 KEY 在字典数据库中的偏移
     
246.         unsigned int keyOFFSET = CHARARRAY2UINT(pBRRAY+UINT_SIZE*2), keyOFFLEN=CHARARRAY2UINT(pBRRAY+UINT_SIZE*3);
     
247. 
     
248.         //转到KEY偏移位置，复制 keyOFFLEN长度数据 至 行缓存容器
     
249.         memcpy(lineCACHE, &((prodb->data)[keyOFFSET]), keyOFFLEN);
     
250. 
     
251.         //置容器结束符
     
252.         lineCACHE[keyOFFLEN]='\0';
     
253. 
     
254.         //显示查询结果
     
255.         char* bp = (char*)lineCACHE;
     
256.         int keyLEN = strlen(srcKEY);
     
257. 
     
258.         while(*bp)
     
259.         {
     
260.                 char* p=Line;
     
261.                 while((*p++ = *bp++) != '\n');
     
262.                 *p='\0';
     
263. 
     
264.                 if(strncmp(Line, srcKEY, keyLEN) == 0)
     
265.                 {
     
266.                         //设置查询真值
     
267.                         bret = true;
     
268. 
     
269.                         //行显查询结果
     
270. #if defined(WIN32) || defined(__WIN32__)
     
271. 
     
272.                         fprintf(stdout, "%s", ANSIteUTF8(Line, CP_UTF8, CP_ACP, wcsCACHE, outCACHE));
     
273. 
     
274. #else
     
275. 
     
276.                         fprintf(stdout, "%s", Line);
     
277. 
     
278. #endif
     
279.                 }
     
280.         }
     
281. 
     
282.         //返还查询真值
     
283.         return bret;
     
284. }
     
285. 
     
286. //*************MAIN主函数入口*************/
     
287. int main(int argc, char** argv)
     
288. {
     
289.         if(argc != 2)
     
290.         {
     
291.                 fprintf(stdout, "Usage: dic [Dictionary file]\n");
     
292.                 return 1;
     
293.         }
     
294. 
     
295.         //打印字典标题
     
296.         fprintf(stdout, "[English-Chinese dictionary] --- use "q" to exit");
     
297. 
     
298.         //构建RODB内存数据库
     
299.         unsigned char* pBRRAY=(unsigned char*)Brray;
     
300.         RODB rodb=CreatRODB(argv[1], '\t', pBRRAY);
     
301. 
     
302.         //构建字典查询 SHELL
     
303.         while(printf("\n>>"), fgets(Input, BUFF_SIZE-1, stdin)!=NULL)
     
304.         {
     
305.                 //将输入转化为字符串
     
306.                 char *p =strchr(Input,'\n');
     
307.                 if(p != NULL)
     
308.                 {
     
309.                         *p='\0';
     
310.                 }
     
311. 
     
312.                 //判断输入是否为空
     
313.                 if (p!=Input)
     
314.                 {
     
315.                         //使用按键 小写q 退出
     
316.                         if(!strcmp(Input, "q"))
     
317.                         {
     
318.                                 fputs("[EXIT]: thanks for use, bye!", stdout);
     
319.                                 break;
     
320.                         }
     
321. 
     
322. #if defined(WIN32) || defined(__WIN32__)
     
323.                         //对WIN32控制台 代码页 兼容
     
324.                         char* srcKEY=ANSIteUTF8(Input, CP_ACP, CP_UTF8, wcsCACHE, outCACHE);
     
325. 
     
326. #else
     
327. 
     
328.                         char* srcKEY=Input;
     
329. 
     
330. #endif
     
331. 
     
332.                         //将被查询字符串转化为索引值
     
333.                         strncpy(Keyic, srcKEY, UINT_SIZE);
     
334.                         unsigned int uSEARCH_INDEX = CHARARRAY2UINT(Keyic);
     
335. 
     
336.                         //执行查询
     
337.                         if(! SearchResultCharArray(&rodb, uSEARCH_INDEX, pBRRAY, lineCACHE, Line, srcKEY) )
     
338.                         {
     
339.                                 fprintf(stdout, "[SORRY]: can not find it\n");
     
340.                         }
     
341. 
     
342.                 }
     
343.         }
     
344.         return 0;
     
345. }
     

复制代码

补充：附带几个移植到手机上的第三方，手机上的控制台一样精彩。包括：bse、choice、dic、equation、revpolish。下载地址：https://page37.ctfile.com/fs/14274637-204820983

老刘1号

希望出GUI版

happy886rr

回复 2# 老刘1号 已更新MFC版，窗口取词，更加速度。

老刘1号

回复 3# happy886rr


    命令行版提示找不到词典，在程序目录或者工作目录下都不行，词典的名称没有更改