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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
LZW15.C
资源名称：inet_stock.zip　[点击查看]
上传用户：bjghjy
上传日期：2007-01-07
资源大小：379k
文件大小：7k
源码类别：

金融证券系统

开发平台：

Visual C++

LZW15.C：源码内容
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  6. #include "lzw.h"
  8. #define         BITS            15
  9. #define         MAX_CODE        ((1L<<BITS) -1 )        //32767
  10. #define         TABLE_SIZE      35023                   //137*256=35072
  11. #define         TABLE_BANKS     ((TABLE_SIZE >> 8) +1)  //137
  12. #define         END_OF_STREAM   256
  13. #define         BUMP_CODE       257
  14. #define         FLUSH_CODE      258
  15. #define         FIRST_CODE      259
  16. #define         UNUSED          -1
  19. typedef struct tag_dictionary
  20. {
  21. short code_value;
  22. short parent_code;
  23. char character;
  24. }dictionary;
  26. int find_child_node(short parent_code,short child_character,dictionary *dict);
  28. //unsigned short decode_string(unsigned short offset,unsigned short code);
  30. void Writelog(char *msg);
  32. //char *CompressionName ="lzw 15 bit Encode";
  33. //char *Usage         ="in-file out-filenn";
  34. //this package inlude file:bitio.c/lzw15.c/lzw.h
  37. #define DICT(i) dict[i >> 8][i&0xff]
  39. //char *decode_stack=NULL;
  41. BOOL CompressFile(char * infile,char *outfile)
  42. {
  43. short character;
  44. short string_code;
  45. unsigned short index;
  46. HANDLE hd;
  47. BIT_FILE * output;
  48. FILE * input;
  49. int ret;
  51. unsigned short next_code;
  52. short current_code_bits;
  53. unsigned short next_bump_code;
  54. unsigned short i;
  56. dictionary *dict;
  58. input = fopen(infile,"rb");
  59. if(input==NULL)
  60. {
  61. fatal_error("Can not open input file");
  62. return FALSE;
  63. }
  64. output =OpenOutputBitFile(outfile);
  65. if(output ==NULL)
  66. {
  67. fatal_error("Can not open output file");
  68. fclose(input);
  69. return FALSE;
  70.  }
  72. hd=HeapCreate((DWORD)0,TABLE_BANKS*256*sizeof(dictionary),(DWORD)0);
  73. if(hd==NULL)
  74. {
  75. CloseOutputBitFile(output);
  76. fclose(input);
  77. return FALSE;
  78. }
  80. //if(!InitializeStorage(hd))
  81. //{
  82. // CloseOutputBitFile(output);
  83. // fclose(input);
  84. // HeapDestroy(hd);
  85. // return FALSE;
  86. //}
  88. dict=HeapAlloc(hd,HEAP_ZERO_MEMORY,TABLE_BANKS*256*sizeof(dictionary));
  89. if(dict== NULL)
  90. {
  91. CloseOutputBitFile(output);
  92. fclose(input);
  93. HeapDestroy(hd);
  94. return FALSE;
  95. }
  96. if(HeapSize(hd,0,dict)<TABLE_BANKS*256*sizeof(dictionary))
  97. {
  98. CloseOutputBitFile(output);
  99. fclose(input);
  100. HeapDestroy(hd);
  101. return FALSE;
  102. }
  104. //InitializeDictionary();
  105. for(i=0;i<TABLE_SIZE;i++)
  106. dict[i].code_value = UNUSED;
  107. next_code =FIRST_CODE;
  108. current_code_bits =9;
  109. next_bump_code =511;
  111. if((string_code = getc(input)) == EOF)
  112. string_code = END_OF_STREAM;
  114. while((character = getc(input))!=EOF)
  115. {
  116. ret =find_child_node(string_code,character,dict);
  117. if(ret<0)
  118. {
  119. CloseOutputBitFile(output);
  120. fclose(input);
  121. HeapDestroy(hd);
  122. return FALSE;
  123. }
  124. index =(unsigned short)ret;
  126. if(dict[index].code_value !=-1)
  127. string_code =dict[index].code_value;
  128. else
  129. {
  130. dict[index].code_value =next_code++;
  131. dict[index].parent_code=string_code;
  132. dict[index].character=(char)character;
  134. OutputBits(output,(unsigned int)string_code,current_code_bits);
  135. string_code =character;
  136. if(next_code>MAX_CODE)
  137. {
  138. OutputBits(output,(unsigned int)FLUSH_CODE,current_code_bits);
  140. //InitializeDictionary();
  141. for(i=0;i<TABLE_SIZE;i++)
  142. dict[i].code_value = UNUSED;
  143. next_code =FIRST_CODE;
  144. current_code_bits =9;
  145. next_bump_code =511;
  146. }
  147. else if(next_code>next_bump_code)
  148. {
  149. OutputBits(output,(unsigned int)BUMP_CODE,current_code_bits);
  150. current_code_bits++;
  151. next_bump_code<<=1;
  152. next_bump_code|=1;
  153. }
  154. }
  155. }
  156. OutputBits(output,(unsigned short)string_code,current_code_bits);
  157. OutputBits(output,(unsigned short)END_OF_STREAM,current_code_bits);
  159. CloseOutputBitFile(output);
  160. fclose(input);
  161. //ExitLzw(hd);
  162. HeapDestroy(hd);
  163. return TRUE;
  164. }
  166. int find_child_node(short parent_code ,short child_character,dictionary *dict)
  167. {
  168. unsigned short index;
  169. unsigned short offset;
  171. index =(child_character <<(BITS-8)) ^parent_code;
  172. if(index ==0)
  173. offset =1;
  174. else
  175. offset =TABLE_SIZE -index;
  176. for(;;)
  177. {
  179. if(IsBadStringPtr((char *)&dict[index],(UINT)sizeof(short)))
  180. return -1;
  181. if(dict[index].code_value ==UNUSED)
  182. return(int)index;
  183. if(dict[index].parent_code ==parent_code &&
  184. dict[index].character ==(char)child_character)
  185. return(int)index;
  186. if(index >=offset)
  187. index =index -offset;
  188. else
  189. index=index +TABLE_SIZE-offset;
  190. }
  191. }
  193. //unsigned short decode_string(unsigned short count,unsigned short code)
  194. //{
  195. // while(code>255)
  196. // {
  197. // decode_stack[count++] =dict[code].character;
  198. // code =dict[code].parent_code;
  199. // }
  200. // decode_stack[count++] =(char)code;
  201. // return(count);
  202. //}
  204. void Writelog(char *msg)
  205. {
  206. OFSTRUCT os;
  207. HFILE hf;
  208.     
  209.     hf=OpenFile("\sv_com32.log",&os,OF_WRITE);
  210. if(hf ==HFILE_ERROR)
  211. hf =OpenFile("\sv_com32.log",&os,OF_WRITE|OF_CREATE);
  212. else
  213. _llseek(hf,0L,SEEK_END);
  214. _lwrite(hf,msg,strlen(msg));
  215. _lclose(hf);
  216. return;
  217. }
  219. short  getmemc(char *buff,int *ylen,int len)
  220. {
  221. unsigned char ret;
  222. if(*ylen<len)
  223. {
  224. ret =buff[*ylen];
  225. *ylen =*ylen +1;
  226. }
  227. else
  228. return EOF;
  229. return ret;
  230. }
  232. BOOL CompressMemFile(char *buff,int len,char *outfile)
  233. {
  234. short character;
  235. short string_code;
  236. unsigned short index;
  237. HANDLE hd;
  238. BIT_FILE * output;
  239. int ylen =0;
  240. char * input;
  241. int ret;
  243. unsigned short next_code;
  244. short current_code_bits;
  245. unsigned short next_bump_code;
  246. unsigned short i;
  248. dictionary *dict;
  250. input = buff;
  251. if(input==NULL||len<0)
  252. {
  253. fatal_error("Can not open mem data");
  254. return FALSE;
  255. }
  256. output =OpenOutputBitFile(outfile);
  257. if(output ==NULL)
  258. {
  259. fatal_error("Can not open output file");
  260. return FALSE;
  261. }
  263. hd=HeapCreate((DWORD)0,TABLE_BANKS*256*sizeof(dictionary),(DWORD)0);
  264. if(hd==NULL)
  265. {
  266. CloseOutputBitFile(output);
  267. return FALSE;
  268. }
  270. //if(!InitializeStorage(hd))
  271. //{
  272. // CloseOutputBitFile(output);
  273. // HeapDestroy(hd);
  274. // return FALSE;
  275. //}
  276. dict=HeapAlloc(hd,HEAP_ZERO_MEMORY,TABLE_BANKS*256*sizeof(dictionary));
  277. if(dict== NULL)
  278. {
  279. CloseOutputBitFile(output);
  280. HeapDestroy(hd);
  281. return FALSE;
  282. }
  283. if(HeapSize(hd,0,dict)<TABLE_BANKS*256*sizeof(dictionary))
  284. {
  285. CloseOutputBitFile(output);
  286. HeapDestroy(hd);
  287. return FALSE;
  288. }
  290. //InitializeDictionary();
  291. for(i=0;i<TABLE_SIZE;i++)
  292. dict[i].code_value = UNUSED;
  293. next_code =FIRST_CODE;
  294. current_code_bits =9;
  295. next_bump_code =511;
  297. if((string_code = getmemc(input,&ylen,len)) == EOF)
  298. string_code = END_OF_STREAM;
  299. while((character = getmemc(input,&ylen,len))!=EOF)
  300. {
  301. ret =find_child_node(string_code,character,dict);
  302. if(ret<0)
  303. {
  304. CloseOutputBitFile(output);
  305. HeapDestroy(hd);
  306. return FALSE;
  307. }
  308. index =(unsigned short)ret;
  310. if(dict[index].code_value !=-1)
  311. string_code =dict[index].code_value;
  312. else
  313. {
  314. dict[index].code_value =next_code++;
  315. dict[index].parent_code=string_code;
  316. dict[index].character=(char)character;
  318. OutputBits(output,(unsigned int)string_code,current_code_bits);
  319. string_code =character;
  320. if(next_code>MAX_CODE)
  321. {
  322. OutputBits(output,(unsigned int)FLUSH_CODE,current_code_bits);
  324. //InitializeDictionary();
  325. for(i=0;i<TABLE_SIZE;i++)
  326. dict[i].code_value = UNUSED;
  327. next_code =FIRST_CODE;
  328. current_code_bits =9;
  329. next_bump_code =511;
  330. }
  331. else if(next_code>next_bump_code)
  332. {
  333. OutputBits(output,(unsigned int)BUMP_CODE,current_code_bits);
  334. current_code_bits++;
  335. next_bump_code<<=1;
  336. next_bump_code|=1;
  337. }
  338. }
  339. }
  340. OutputBits(output,(unsigned short)string_code,current_code_bits);
  341. OutputBits(output,(unsigned short)END_OF_STREAM,current_code_bits);
  343. CloseOutputBitFile(output);
  344. HeapDestroy(hd);
  345. return TRUE;
  346. }