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

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

金融证券系统

开发平台：

Visual C++

SV_DATA.C：源码内容
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <time.h>
  6. #include <io.h>
  8. #include "hq.h"
  9. #include "data.h"
  10. #include "sv_dbf.h"
  11. #include "lzw.h"
  13. extern BOOL run_cancelled;
  15. extern HWND ghWndMain;
  16. extern int date_num, tim;
  17. HFILE hfHq[2], hfMmp[2], hfDp, hfMaxMin[2];
  18. extern void MsgLocal(LPSTR msg);
  19. extern BOOL ErrMsg(HWND, LPSTR);
  20. extern int UDPBlockingHook(void);
  21. extern long oldCjss[2];
  22. extern BOOL IsZsRec(int, int);
  24. //extern int RefreshHqData(int jys);
  26. extern char szDataPath[128];
  27. long zs_times[2][20];
  29. BOOL fWrited[2] ={FALSE, FALSE};
  31. int WriteHqAll(int jys)
  32. {
  33. if(WriteHqData(jys) <0) return -1;
  34. if(WriteMmpData(jys) <0) return -1;
  35. if(WriteMaxMinData(jys) <0) return -1;
  37. return 0;
  38. }
  40. int WriteHqData(int jys)
  41. {
  42. _llseek(hfHq[jys], 0, SEEK_SET);
  43. _lwrite(hfHq[jys], (short *)&HqData[jys].recCount, sizeof(short));
  44. if(_hwrite(hfHq[jys], HqData[jys].lpPreData,
  45. (long)HqData[jys].recCount*sizeof(HQ_PRE_DATA))
  46. !=(long)HqData[jys].recCount*sizeof(HQ_PRE_DATA))
  47. {
  48. ErrMsg(ghWndMain, "Error write hqdata");
  49. return -1;
  50. }
  52. if(_hwrite(hfHq[jys], HqData[jys].lpRefData,
  53. (long)HqData[jys].recCount*sizeof(HQ_REF_DATA))
  54. !=(long)HqData[jys].recCount*sizeof(HQ_REF_DATA))
  55. {
  56. ErrMsg(ghWndMain, "Error write hqdata");
  57. return -1;
  58. }
  59. CreateLzwFile(jys);
  60. return 0;
  61. }
  63. //////////////////////////////////////////////////////////////////////////
  64. //Function:to reduce transfer time between server and client,we must build
  65. //         compress data.this prog compress main mass data(szhq.dat.shhq.dat)
  66. //Para    :None
  67. //Return  :if successful return 0,otherwise return -1
  68. //Writer  :lym
  69. //Create  :1997/08/24
  70. //////////////////////////////////////////////////////////////////////////
  71. int CreateLzwFile(int jys)
  72. {
  73. char temp[256]; //,tmp[256];
  74.     OFSTRUCT os;                 
  75.     HQ_REF_DATA_V202  DataV202;
  76.     long i;
  77.     int lzw;
  78.     
  79.     //for(jys=0;jys<2;jys++)
  80.     //{   
  81. if(HqData[jys].recCount==0)
  82. return(-1);
  83. if(jys==0)
  84. sprintf(temp,"%s\hqdata\szhq.202",szDataPath);
  85. else
  86. sprintf(temp,"%s\hqdata\shhq.202",szDataPath);
  88. if((lzw=OpenFile(temp,&os,OF_WRITE|OF_SHARE_DENY_NONE))==HFILE_ERROR)
  89. if((lzw=OpenFile(temp,&os,OF_WRITE|OF_SHARE_DENY_NONE|OF_CREATE))==HFILE_ERROR)
  90. return(-1);
  92. _lwrite(lzw, (short *)&HqData[jys].recCount, sizeof(short));
  93. for(i=0;i<HqData[jys].recCount;i++)
  94. {
  95. while(UDPBlockingHook());
  96. if(run_cancelled) break;
  97. memset((char*)&DataV202,0,sizeof(HQ_REF_DATA_V202));
  98.  
  99.   strcpy(DataV202.zqdm,HqData[jys].lpPreData[i].zqdm);
  100.   strcpy(DataV202.zqmc,HqData[jys].lpPreData[i].zqmc);
  101.         
  102.          sprintf(temp,"%7.2f",HqData[jys].lpRefData[i].zdjg*100.00);
  103.   DataV202.zdjg =atol(temp);
  104.  
  105.   sprintf(temp,"%7.2f",HqData[jys].lpPreData[i].zrsp*100.00);
  106.   DataV202.zrsp =atol(temp)-DataV202.zdjg;
  107.  
  108.   sprintf(temp,"%7.2f",HqData[jys].lpPreData[i].jrkp*100.00);
  109.   DataV202.jrkp =atol(temp)-DataV202.zdjg;
  110.  
  111.   sprintf(temp,"%7.2f",HqData[jys].lpRefData[i].zgjg*100.00);
  112.   DataV202.zgjg =atol(temp)-DataV202.zdjg;
  113.  
  114.   sprintf(temp,"%7.2f",HqData[jys].lpRefData[i].zdjm*100.00);
  115.   DataV202.zdjm =atol(temp)-DataV202.zdjg;
  116.  
  117.   sprintf(temp,"%7.2f",HqData[jys].lpRefData[i].zgjm*100.00);
  118.   DataV202.zgjm =atol(temp)-DataV202.zdjg;
  119.  
  120.   sprintf(temp,"%7.2f",HqData[jys].lpRefData[i].zjjg*100.00);
  121.   DataV202.zjjg =atol(temp)-DataV202.zdjg;
  122.  
  123.   sprintf(temp,"%7.2f",HqData[jys].lpRefData[i].wb*100.00);
  124.   DataV202.wb =atol(temp);
  125.  
  126.   DataV202.cjss =HqData[jys].lpRefData[i].cjss;
  127.   DataV202.npzl =HqData[jys].lpRefData[i].npzl;
  128.   DataV202.cjje =HqData[jys].lpRefData[i].cjje;
  129. _lwrite(lzw,(char *)&DataV202,sizeof(HQ_REF_DATA_V202));
  130. }
  131. _lclose(lzw);
  132. return TRUE;
  133. }
  135. int WriteDpData(int jys)
  136. {
  137. _llseek(hfDp, jys*sizeof(DpData[jys]), SEEK_SET);
  138. _lwrite(hfDp, &DpData[jys], sizeof(DpData[jys]));
  140. return 0;
  141. }
  143. int WriteMmpData(int jys)
  144. {
  145. _llseek(hfMmp[jys], 0, SEEK_SET);
  146. //_lwrite(hfMmp[jys], (int *)&MmpData[jys].recCount, sizeof(int));
  147. if(_hwrite(hfMmp[jys], MmpData[jys].lpMmp, (long)sizeof(MMP)*HqData[jys].recCount)
  148. !=(long)sizeof(MMP)*HqData[jys].recCount)
  149. {
  150. ErrMsg(NULL, "Write mmp failed");
  151. return -1;
  152. }
  154. return 0;
  155. }
  157. int WriteMaxMinData(int jys)
  158. {
  159. _llseek(hfMaxMin[jys], 0, SEEK_SET);
  160. _lwrite(hfMaxMin[jys], &MaxMinData[jys], sizeof(MaxMinData[jys]));
  162. return 0;
  163. }
  165. long max_l(long val1, long val2)
  166. {
  167. return (val1>val2)? val1:val2;
  168. }
  169. long min_l(long val1, long val2)
  170. {
  171. return (val1<val2)? val1:val2;
  172. }
  173. float max_f(float val1, float val2)
  174. {
  175. return (val1>val2)? val1:val2;
  176. }
  177. float min_f(float val1, float val2)
  178. {
  179. return (val1<val2)? val1:val2;
  180. }
  182. extern void MsgRecv(char far *msg);
  183. //////////////////////////////////////////////////
  184. //功能 ：读取分时数据文件，初始化内存分时数据头部信息
  185. //参数 ：
  186. //    jys---交易所编码
  187. //返回码 ：
  188. //    0  ---成功
  189. //         -1 ---失败
  190. //修改日期 ：1997/10/15
  191.   
  192. int CheckGraHead(int jys)
  193. {
  194. int i;
  195. char temp[128];
  196. HFILE hFile;
  197. OFSTRUCT os;
  199. wsprintf(temp, "检查分时数据头:%d", jys);
  200. MsgLocal(temp);
  201. for(i =0; i<HqData[jys].recCount; i++)
  202. {
  203. while(UDPBlockingHook());
  204. if(run_cancelled) break;
  206. wsprintf(temp, "%s\%s.dat",
  207. GraphData[jys].szGraPath,
  208. HqData[jys].lpPreData[i].zqdm);
  209. hFile =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_READ);
  210. //打开文件失败，必需重新初始化内存分时数据头部信息
  211. if(hFile ==HFILE_ERROR)
  212. goto reset_values;
  213. else
  214. {
  215. //该内存分时数据头部信息读不出，必需重新初始化
  216. if(_lread(hFile, &GraphData[jys].lpGraHead[i],
  217. sizeof(GRA_HEAD)) !=sizeof(GRA_HEAD))
  218. goto reset_values;
  219. //该内存分时数据头部信息日期错，必需重新初始化
  220. if(GraphData[jys].lpGraHead[i].dateNum !=date_num)
  221. goto reset_values;
  222. _lclose(hFile);
  223. //至此说明该内存分时数据头部信息正确，但如存在成交量查，则必须调整
  224. //内存行情数据的内盘总量
  225. HqData[jys].lpRefData[i].npzl =GraphData[jys].lpGraHead[i].npzl
  226. +(HqData[jys].lpRefData[i].cjss-GraphData[jys].lpGraHead[i].npzl
  227. -GraphData[jys].lpGraHead[i].wpzl)/2;
  228. continue;
  229. }
  230. reset_values:
  231. HqData[jys].lpRefData[i].npzl =HqData[jys].lpRefData[i].cjss/2;
  232. memset(&GraphData[jys].lpGraHead[i], 0, sizeof(GRA_HEAD));
  233. GraphData[jys].lpGraHead[i].dateNum =date_num;
  234. GraphData[jys].lpGraHead[i].zrsp =HqData[jys].lpPreData[i].zrsp;
  235. GraphData[jys].lpGraHead[i].zgjg =GraphData[jys].lpGraHead[i].zdjg
  236. =HqData[jys].lpRefData[i].zjjg-HqData[jys].lpPreData[i].zrsp;
  237. if(hFile ==HFILE_ERROR)
  238. {
  239. hFile =OpenFile(temp, &os, OF_SHARE_DENY_NONE|OF_CREATE|OF_READWRITE);
  240. if(hFile ==HFILE_ERROR) continue;
  241. }
  242. _lclose(hFile);
  243. }
  244. return 0;
  245. }
  247. BOOL WriteGraData(int jys,int i)
  248. { 
  249. char tmp[50];
  250. HFILE hFile;
  251. OFSTRUCT os;
  252.  
  253. wsprintf(tmp, "%s\%s.dat", GraphData[jys].szGraPath,
  254. HqData[jys].lpPreData[i].zqdm);
  255. //GraphData[jys].lpGraHead[i].dateNum =date_num;
  256. //GraphData[jys].lpGraHead.zrsp =HqData[jys].lpRefData[i].zrsp;
  257. //GraphData[jys].lpGraData[i].tim =tim;
  258. hFile =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_READWRITE);
  259. if(hFile ==HFILE_ERROR)
  260. return FALSE;
  261. if(_llseek(hFile, sizeof(GRA_HEAD)+(GraphData[jys].lpGraHead[i].minCount-1)*sizeof(GRA_DATA),
  262. SEEK_SET) ==HFILE_ERROR)
  263. return FALSE;
  264. _lwrite(hFile, &GraphData[jys].lpGraData[i],sizeof(GRA_DATA));
  265. _llseek(hFile, 0, SEEK_SET);
  266. _lwrite(hFile, &GraphData[jys].lpGraHead[i],sizeof(GRA_HEAD));
  267. _lclose(hFile);
  269. return TRUE;
  270. }
  272. int WriteMinData(int jys)
  273. {
  274. return 0;
  275. }
  277. BOOL WriteDayData(int jys)
  278. {
  279. int i;
  280. long day_cur;
  281. char tmp[128];
  282. DAY_DATA dayData;
  283. HFILE hFile;
  284. OFSTRUCT os;
  285. time_t ltime;
  286. struct tm *ptm;
  287. //static BOOL fWrited[2] ={FALSE, FALSE};
  288. long len;
  289.     
  290. if(fWrited[jys])
  291. {
  292. MsgLocal("history data already writed!");
  293. return TRUE;
  294. }
  296. MsgLocal("Write day data...");
  297.     
  298. time(&ltime);
  299. ptm =localtime(&ltime);
  300. day_cur =(long)(1900+ptm->tm_year)*10000+(long)(ptm->tm_mon+1)*100+ptm->tm_mday;
  302. for (i=0;i<HqData[jys].recCount;i++) 
  303. {         
  304. while(UDPBlockingHook());
  305. if(run_cancelled) break;
  307. if(GraphData[jys].lpGraHead[i].minCount <=0) continue;
  309. wsprintf(tmp, "%s\%s\%s.day", szDataPath, (jys ==0)?"SZDAY":"SHDAY",
  310. HqData[jys].lpPreData[i].zqdm);                          
  311. hFile =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_READWRITE);
  312. if(hFile ==HFILE_ERROR)
  313. {
  314. hFile =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_CREATE|OF_READWRITE);
  315. if(hFile ==HFILE_ERROR)
  316. {
  317. ErrMsg(NULL, "Create file failed");
  318. ErrMsg(NULL, tmp);
  319. continue;
  320. }
  321. }
  322. else
  323. {
  324. _llseek(hFile, 0, SEEK_SET);
  325. len =_llseek(hFile, 0, SEEK_END);
  326. if(len!=0)
  327. {
  328. if(_llseek(hFile, len-sizeof(dayData), SEEK_SET) ==HFILE_ERROR)
  329. {
  330. _llseek(hFile, 0, SEEK_SET);
  331. }
  332. else if(_lread(hFile, &dayData, sizeof(dayData))
  333. !=sizeof(dayData))
  334. {
  335. ErrMsg(NULL, "Read file failed");
  336. ErrMsg(NULL, tmp);
  337. _lclose(hFile);
  338. continue;
  339. }
  340. else if(dayData.day ==day_cur)
  341. {
  342. _lclose(hFile);
  343. continue;
  344. }
  345. }
  346. }
  347. dayData.day =day_cur;
  348. dayData.kpjg =HqData[jys].lpPreData[i].jrkp;
  349. dayData.spjg =HqData[jys].lpRefData[i].zjjg;
  350. dayData.zgjg =HqData[jys].lpRefData[i].zgjg;
  351. dayData.zdjg =HqData[jys].lpRefData[i].zdjg;
  352. dayData.cjss =HqData[jys].lpRefData[i].cjss;
  353. dayData.cjje =HqData[jys].lpRefData[i].cjje;
  355. _lwrite(hFile,&dayData,sizeof(DAY_DATA));
  357. _lclose(hFile);
  358. }    
  360. MsgLocal("Write day data ok");
  361. fWrited[jys] =TRUE;
  363. return TRUE;
  364. }
  366. BOOL WriteWeekData(int jys)
  367. {
  368. int i,j;
  369. char tmp[100];
  370. HISTORY_DATA WeekData,DayData,NextDayData;
  371. HFILE hWeekFile,hDayFile;
  372. OFSTRUCT os;
  373. time_t c_time1,c_time2;
  374. static BOOL fWrited[2] ={FALSE, FALSE};
  375.     
  376. if(fWrited[jys])
  377. {
  378. MsgLocal("week data already writed");
  379. return TRUE;
  380. }
  381. MsgLocal("Write week data...");
  382. for (i=0;i<HqData[jys].recCount;i++) 
  383. {   
  384. while(UDPBlockingHook());
  385. if(run_cancelled) break;
  386. //打开日线文件
  387. memset(tmp,0,100);                                                              
  388. if(jys==0)
  389. wsprintf(tmp, "%s%s.day","szase\day\" ,
  390. HqData[jys].lpPreData[i].zqdm);                          
  391. else
  392. wsprintf(tmp, "%s%s.day","shase\day\" ,
  393. HqData[jys].lpPreData[i].zqdm);                          
  395. //MsgLocal(HqData[jys].lpPreData[i].zqdm);      
  396. hDayFile =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_READWRITE);
  397. if(hDayFile ==HFILE_ERROR)
  398. {
  399. _lclose(hDayFile);
  400. continue;               
  401. }
  402. _llseek(hDayFile,-1*(long)(sizeof(HISTORY_DATA)),SEEK_END);
  403. if(_lread(hDayFile,&DayData,sizeof(HISTORY_DATA))!=
  404. sizeof(HISTORY_DATA))
  405. {          
  406. _lclose(hDayFile);      
  407. continue;
  408. }        
  410. memcpy(&WeekData,&DayData,sizeof(HISTORY_DATA));        
  411. memcpy(&c_time1,DayData.date+6,sizeof(time_t));
  413. j=2;            
  414. while(TRUE)
  415. {   
  416. if(j>7) break;
  417.     _llseek(hDayFile,-j*(long)(sizeof(HISTORY_DATA)),SEEK_END);
  418. if(_lread(hDayFile,&NextDayData,sizeof(HISTORY_DATA))!=
  419. sizeof(HISTORY_DATA))                           
  420. break;                          
  421. memcpy(&c_time2,NextDayData.date+6,sizeof(time_t));      
  422. if((int)(difftime(c_time1,c_time2)/(24.00*60.00))>=7)
  423. break;
  424. //计算周线  
  425. WeekData.ks=NextDayData.ks;
  426. WeekData.cj+=NextDayData.cj;
  427. if(WeekData.zg<NextDayData.zg)  WeekData.zg=NextDayData.zg;
  428. if(WeekData.zd>NextDayData.zd)  WeekData.zg=NextDayData.zd;                     
  429. j++;    
  430. }               
  431. //写周线文件            
  432. if(jys==0)
  433. wsprintf(tmp, "%s%s.wek","szase\week\",
  434. HqData[jys].lpPreData[i].zqdm);
  435. else
  436. wsprintf(tmp, "%s%s.wek","shase\week\",
  437. HqData[jys].lpPreData[i].zqdm);
  438. hWeekFile =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_READWRITE);
  439. if(hWeekFile ==HFILE_ERROR)
  440. {
  441. hWeekFile =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_CREATE|OF_READWRITE);
  442. }  
  443. _llseek(hWeekFile,0L,SEEK_END);
  444. _lwrite(hWeekFile,&WeekData,sizeof(HISTORY_DATA));
  445. _lclose(hWeekFile);
  446. _lclose(hDayFile);
  447.     }
  448. MsgLocal("Write week data ok");
  449. fWrited[jys] =TRUE;
  450. return TRUE;
  451. }
  453. BOOL WriteMonthData(int jys)
  454. {
  455.     int i,j;
  456.     char tmp[100];
  457.     HISTORY_DATA WeekData,MonthData,NextWeekData;
  458. HFILE hWeekFile,hMonthFile;
  459. OFSTRUCT os;
  460. static BOOL fWrited[2] ={FALSE, FALSE};
  462. if(fWrited[jys])
  463. {
  464. MsgLocal("month data already writed!");
  465. return TRUE;
  466. }
  467. MsgLocal("Write month data...");
  468. for (i=0;i<HqData[jys].recCount;i++) 
  469. {   
  470. while(UDPBlockingHook());
  471. if(run_cancelled) break;
  472. //打开周线文件
  473.     if(jys==0)
  474. wsprintf(tmp, "%s%s.wek","szase\week\" ,
  475. HqData[jys].lpPreData[i].zqdm);                          
  476. else
  477. wsprintf(tmp, "%s%s.wek","shase\week\" ,
  478. HqData[jys].lpPreData[i].zqdm);                          
  480. //MsgLocal(HqData[jys].lpPreData[i].zqdm);      
  481. hWeekFile =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_READWRITE);
  482. if(hWeekFile ==HFILE_ERROR)
  483. {
  484. _lclose(hWeekFile);
  485. continue;               
  486. }
  487. _llseek(hWeekFile,-1*(long)(sizeof(HISTORY_DATA)),SEEK_END);
  488. if(_lread(hWeekFile,&WeekData,sizeof(HISTORY_DATA))!=
  489. sizeof(HISTORY_DATA))
  490. {          
  491. _lclose(hWeekFile);     
  492. continue;
  493. }        
  495. memcpy(&MonthData,&WeekData,sizeof(HISTORY_DATA));        
  497. j=2;            
  498. while(TRUE)
  499. {   
  500. if(j>31)        break;
  501.     _llseek(hWeekFile,-j*(long)(sizeof(HISTORY_DATA)),SEEK_END);
  502. if(_lread(hWeekFile,&NextWeekData,sizeof(HISTORY_DATA))!=
  503. sizeof(HISTORY_DATA))                           
  504. break;                  
  505. if(!strncmp(WeekData.date+2,NextWeekData.date+2,2))
  506. break;
  507. //计算月线  
  508. MonthData.ks=NextWeekData.ks;
  509. MonthData.cj+=NextWeekData.cj;
  510. if(MonthData.zg<NextWeekData.zg)  MonthData.zg=NextWeekData.zg;
  511. if(MonthData.zd>NextWeekData.zd)  MonthData.zg=NextWeekData.zd;                 
  512. j++;    
  513. }               
  514. //写月线文件            
  515. if(jys==0)
  516. wsprintf(tmp, "%s%s.mot","szase\month\",
  517. HqData[jys].lpPreData[i].zqdm);
  518. else
  519. wsprintf(tmp, "%s%s.mot","shase\month\",
  520. HqData[jys].lpPreData[i].zqdm);
  521. hMonthFile =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_READWRITE);
  522. if(hMonthFile ==HFILE_ERROR)
  523. {
  524. hMonthFile =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_CREATE|OF_READWRITE);
  525. }  
  526. _llseek(hMonthFile,0L,SEEK_END);
  527. _lwrite(hMonthFile,&MonthData,sizeof(HISTORY_DATA));
  528. _lclose(hMonthFile);
  529. _lclose(hWeekFile);
  530.     }
  531. MsgLocal("Write month data ok");
  532. fWrited[jys] =TRUE;
  533. return TRUE;
  534. }