sv_hq.c

站长96年写的一个Internet上用的股票行情、分析、交易、资讯程序源码

#include <windows.h>
#include <windowsx.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <io.h>
#include <sys\stat.h>
#include <share.h>
#include <fcntl.h>
#include <time.h>

#include "hq.h"
#include "sv_hq.h"
#include "sv_hqk.h"
#include "data.h"
                              
HQ_DATA HqData[2];            //行情内存对象
DP_DATA DpData[2];            //大盘内存对象
MMP_DATA MmpData[2];          //买卖盘内存对象
GRA_ALL GraphData[2];         //分时数据头部信息
MAXMIN_DATA MaxMinData[2][2]; //排行榜内存对象

HQ_TIME HqTime[2]; 
DBF_DATA HqkData[2], GpkData[2], SzZskData, SzMmpkData;
HQSEL_DATA HqSelData;
ZX_DATA ZxData;

extern void DelayMs(int ms);
int SendHq(int jys);
int GetShZsFirst(LPSTR lpbuf, int);
int RefreshShZs(LPSTR lpbuf, int);
int GetSzZqmc(int);
long CalcCjzje(int jys);
float CalcNpbl(int jys);
long CalcCjss(int jys);
BOOL IsTodayHq(int);
BOOL ReadHqDat(int);
int GetGraData(int jys, int i, LPHQ_REF_DATA lpLastHq);
int GetDpGraData(int jys, int i);
BOOL IsGuoZhai(int, int);

int GetValidRecNum(int jys);

extern BOOL WriteGraData(int,int);
extern int ConnectHost(void);
extern long zs_times[2][20];
extern long tim_seconds;

extern HWND ghWndMain;                           

extern void MsgLocal(LPSTR msg);
extern void DelSpaces(LPSTR);
extern BOOL GetInitString(LPSTR, LPSTR, LPSTR);
extern void PutInitString(LPSTR, LPSTR, LPSTR);
extern int GetInitInt(LPSTR, LPSTR);
extern BOOL ErrMsg(HWND, LPSTR);
extern int UDPBlockingHook(void);
extern BOOL run_cancelled;
extern int UDP_SendBuff(int, LPSTR, int);

extern int date_num,tim;

LPSTR GetHqFldPos(int jys, int rec_num, int fld_num);

int keys[600];     // must init first

int HqAllocMem(int jys, int recCount);
int SendMmp(int jys);
int SendDp(int jys);
int SendMaxMin(int jys, int type);
int GetMaxMin10(int jys);

void GetMaxZd10(int jys);
void GetMinZd10(int jys);
void GetMaxZdf10(int jys);
void GetMinZdf10(int jys);
void GetMaxCjss10(int jys);
void GetMinCjss10(int jys);
void GetMaxCjje10(int jys);
void GetMinCjje10(int jys);

int GetLongSort10(int jys, int fldNum, int type, int *);
int GetFloatSort10(int jys, int fldNum, int type, int *);
BOOL IsMaxMin(int jys, int rec_num);

char *HqItems[] ={"HQK_SZ", "HQK_SH", "GPK_SZ", /*"GPK_SH",*/
					"ZSK_SZ", "MMPK_SZ", NULL};

LPDBF_DATA lpDbfDatas[]={&HqkData[0], &HqkData[1],
						&GpkData[0],/* &GpkData[1],*/
						&SzZskData,
						&SzMmpkData,NULL};

LPDBF_DATA 	lpDbfFile[2][5] ={
								{&HqkData[0],&GpkData[0],&SzZskData,&SzMmpkData,NULL},
								{&HqkData[1],NULL,       NULL,      NULL,       NULL}
							};

						
LPSTR HqTimeItems[] ={"SZ_AM_START", "SZ_AM_END", "SZ_PM_START", "SZ_PM_END",
					"SH_AM_START", "SH_AM_END", "SH_PM_START", "SH_PM_END",
};

LPSTR HqTimeDefs[] ={"9:30", "11:30", "13:00", "15:00",
					"9:30", "11:30", "13:00", "15:00",
};

int *lpHqTimes[] ={&HqTime[0].am_min_start, &HqTime[0].am_min_end,
				&HqTime[0].pm_min_start, &HqTime[0].pm_min_end,
				&HqTime[1].am_min_start, &HqTime[1].am_min_end,
				&HqTime[1].pm_min_start, &HqTime[1].pm_min_end
};

int zsRecNum[2][50];
int zsRecCount[2] ={0,0};
long oldDpCjss2[2][20];
int gnHqRefreshTime =5;

char HqDataPath[128], szDataPath[128];

int *HqDataFile[] ={
	&hfHq[0], &hfHq[1], &hfMmp[0], &hfMmp[1], &hfDp,
	&hfMaxMin[0], &hfMaxMin[1], NULL
};

LPSTR HqDataFileName[] ={
	"SZHQ", "SHHQ", "SZMMP", "SHMMP", "DPDATA", "MAXMINSZ", "MAXMINSH", NULL
};
  
  
int Skip = -1,Idel;
  
int HqInit(void)
{
	int i, jys;
	char tmp[256], temp[256];
	OFSTRUCT os;
	
	memset(&oldDpCjss2, 0, sizeof(oldDpCjss2));
	memset(&zs_times, 0, sizeof(zs_times));
	for(i =0; i<2; i++)
	{
		memset(&HqData[i], 0, sizeof(HqData[i]));
		memset(&MmpData[i], 0, sizeof(MmpData[i]));
		memset(&HqTime[i], 0, sizeof(HqTime[i]));
		memset(&GraphData[i], 0, sizeof(GraphData[i]));
		memset(&DpData[i], 0, sizeof(DpData[i]));
		hfHq[i] =HFILE_ERROR;
		hfMmp[i] =HFILE_ERROR;
		hfMaxMin[i] =HFILE_ERROR;
	}
	hfDp =HFILE_ERROR;
	memset(&ZxData, 0, sizeof(ZxData));
	i=0;
	while(HqItems[i])
	{
		memset(lpDbfDatas[i], 0, sizeof(DBF_DATA));
		lpDbfDatas[i]->hf =-1;
		i++;
	}

    /*
    memset(tmp,0,sizeof(tmp));
	if(GetInitString("GLOBAL", "SKIP", tmp))
	{
		Skip= atoi(tmp);
	}
	else
	{
		PutInitString("GLOBAL", "SKIP", "0");
		Skip=0;
	}
    */

    memset(tmp,0,sizeof(tmp));
	if(GetInitString("GLOBAL", "IDEL", tmp))
	{
		Idel= atoi(tmp);
	}
	else
	{
		PutInitString("GLOBAL", "IDEL", "0");
		Idel=0;
	}
	
	//设置开闭市时间
	for(jys =0; jys <2; jys++)
	{
		for(i =0; i<4; i++)
		{
			if(!GetInitString("TIME", HqTimeItems[i+4*jys], tmp))
			{
				strcpy(tmp, HqTimeDefs[i+4*jys]);
				PutInitString("TIME", HqTimeItems[i+4*jys], tmp);
			}
			else
			{
				if(strlen(tmp) > 12 || strlen(tmp) <3)
				{
					ErrMsg(ghWndMain, "time set error!");
					return -1;
				}
			}
			*lpHqTimes[i+4*jys] =atoi(strtok(tmp, ":"))*60;
			*lpHqTimes[i+4*jys] +=atoi(strtok(NULL, ":"));
		}
	
	}
    
    //初始化DBF文件
	i =0;
	while(HqItems[i])
	{
		if(!GetInitString("DBF", HqItems[i], tmp))
		{
			wsprintf(temp, "can not find %s:\n %s",
					(LPSTR)HqItems[i], (LPSTR)tmp);
			ErrMsg(ghWndMain, temp);
			PutInitString("DBF", HqItems[i], NULL);
			return -1;
		}
		
		if(access(tmp,_S_IREAD) <0)
		{
			wsprintf(temp, "can not read %s:\n %s",
					(LPSTR)HqItems[i], (LPSTR)tmp);
			ErrMsg(ghWndMain, temp);
			return -1;
		}  
		lpDbfDatas[i]->hf=OpenDbfBase(tmp,OF_READ);
		if (lpDbfDatas[i]->hf==-1)
		{
			wsprintf(temp, "can not open %s:\n %s",
					(LPSTR)HqItems[i], (LPSTR)tmp);
			ErrMsg(ghWndMain, temp);
			return -1;
		}
		strcpy(lpDbfDatas[i]->file,tmp); 
		
		if (InitBase(lpDbfDatas[i]->hf,&lpDbfDatas[i]->dbfStruct,
				&lpDbfDatas[i]->fldStruct,&lpDbfDatas[i]->fldCount)
			!=SUCCEED) 
		{
			wsprintf(temp, "can not init %s:\n %s",
					(LPSTR)HqItems[i], (LPSTR)tmp);
			ErrMsg(ghWndMain, temp);
			return -1;
		}
		
		i++;
	}
	
    //初始化分时数据结构
	if(!GetInitString("HQ", "DATAPATH", szDataPath))
	{
		ErrMsg(ghWndMain, "not set datapath in [graph]");
		PutInitString("HQ", "DATAPATH", NULL);
		return -1;
	}
	i =strlen(szDataPath);
	if(szDataPath[i] =='\\')
		szDataPath[i] =0;
	
	wsprintf(HqDataPath, "%s\\HQDATA", szDataPath);
	wsprintf(GraphData[0].szGraPath, "%s\\SZDATA", szDataPath);
	wsprintf(GraphData[1].szGraPath, "%s\\SHDATA", szDataPath);
	
	//初始化行情数据文件
	i =0;
	while(HqDataFileName[i])
	{
		wsprintf(tmp, "%s\\%s.dat", HqDataPath, HqDataFileName[i]);
		if(access(tmp,_S_IREAD) <0)
		{
			*HqDataFile[i] =OpenFile(tmp,&os, OF_SHARE_DENY_NONE|OF_CREATE|OF_READWRITE);
			if(*HqDataFile[i] ==-1)
			{
				wsprintf(temp, "can not create hq_data_file %s:", tmp);
				ErrMsg(ghWndMain, temp);
				return -1;
			}
		}  
		else *HqDataFile[i] =OpenFile(tmp, &os, OF_SHARE_DENY_NONE|OF_READWRITE);
		if (*HqDataFile[i] ==NULL)
		{
			wsprintf(temp, "can not open hq_data_file %s:", tmp);
			ErrMsg(ghWndMain, temp);
			return -1;
		} 
		i++;
	}

	gnHqRefreshTime =GetInitInt("HQ", "REF_TIME");
	if(gnHqRefreshTime <5 || gnHqRefreshTime >60) gnHqRefreshTime =5;
    
    
	for(jys =0; jys <2; jys++)
	{
		CloseDbfFile(jys);
	}
	
	return 0;
}

void HqExit(void)
{
	static BOOL fExit =FALSE;
	int jys, i;
	
	if(fExit ==TRUE) return;
	fExit =TRUE;
	for(jys =0; jys <2; jys++)
	{
		if(HqData[jys].lpPreData !=NULL) GlobalFreePtr(HqData[jys].lpPreData);
		if(HqData[jys].lpRefData !=NULL) GlobalFreePtr(HqData[jys].lpRefData);
		if(HqData[jys].lpbChanged !=NULL) GlobalFreePtr(HqData[jys].lpbChanged);
		if(MmpData[jys].lpMmp) GlobalFreePtr(MmpData[jys].lpMmp);
		if(GraphData[jys].lpGraData) GlobalFreePtr(GraphData[jys].lpGraData);
		if(GraphData[jys].lpGraHead) GlobalFreePtr(GraphData[jys].lpGraHead);
		
		if(hfHq[jys] !=HFILE_ERROR) _lclose(hfHq[jys]);
		if(hfMmp[jys] !=HFILE_ERROR) _lclose(hfMmp[jys]);
		if(hfMaxMin[jys] !=HFILE_ERROR) _lclose(hfMaxMin[jys]);
	}
	if(hfDp !=HFILE_ERROR) _lclose(hfDp);
	i =0;
	while(HqItems[i])
	{
		if(lpDbfDatas[i]->hf!=-1)
		{
			CloseDbf(lpDbfDatas[i]->hf);
			//if(lpDbfDatas[i]->fldStruct)
			//	free(lpDbfDatas[i]->fldStruct);
		}
		if(lpDbfDatas[i]->fldStruct)
			free(lpDbfDatas[i]->fldStruct);		
		i++;
	}
	
	if(ZxData.lpText) free(ZxData.lpText);
}


BOOL OpenDbfFile(int jys)
{
	int i =0;
	
	while(lpDbfFile[jys][i]!=NULL)
	{   
		if(lpDbfFile[jys][i]->hf==-1)
			lpDbfFile[jys][i]->hf =OpenDbfBase(lpDbfFile[jys][i]->file,OF_READ);
		if(lpDbfFile[jys][i]->hf == -1)
			return FALSE;
		i++;
	}
	return TRUE;
}


void CloseDbfFile(int jys)
{
	int i=0;
	
    while(lpDbfFile[jys][i]!=NULL)
    {
    	if(lpDbfFile[jys][i]->hf!=-1)
    	{
 			CloseDbf(lpDbfFile[jys][i]->hf);
 			lpDbfFile[jys][i]->hf =-1; 			
 		}
 		i++;
 	} 	
}



//zqdm,zrsp,jrkp,zgjg,zdjg,zgjm,zdjm,zjjg,zd,cjss,lc,npzl,wb,cjje
int HqFldLens[HQ_FLDS_COUNT]=
{
	MAX_ZQDM_SIZE, sizeof(float),sizeof(float), sizeof(float), sizeof(float),
	sizeof(float), sizeof(float), sizeof(float), sizeof(float),sizeof(long),
	sizeof(long), sizeof(long), sizeof(float), sizeof(long)
};

int HqFldTypes[HQ_FLDS_COUNT]=
{
	FLD_TYPE_STRING, FLD_TYPE_FLOAT, FLD_TYPE_FLOAT, FLD_TYPE_FLOAT,
	FLD_TYPE_FLOAT, FLD_TYPE_FLOAT, FLD_TYPE_FLOAT, FLD_TYPE_FLOAT,
	FLD_TYPE_FLOAT, FLD_TYPE_LONG,  FLD_TYPE_LONG, FLD_TYPE_LONG,
	FLD_TYPE_FLOAT, FLD_TYPE_LONG
};

int HqFldPoss[2][HQ_FLDS_COUNT] =
{
	//0zqdm,1zrsp,2jrkp,3zgjg,4zdjg,5zgjm,6zdjm,7zjjg,8zd,9cjss,0lc,11npzl,
	//12wb,13cjje
	//{0, 2, 3, 5, 6, 8, 9, 7, -1,  4, -1,-1, -1, 15},
	{0, 1, 2, 4, 5, 7, 8, 6, -1,  3, -1,-1, -1, 14},
	{0, 2, 3, 5, 6, 8, 9, 7, -1, 10, -1, -1, -1, 4},
};

BOOL IsTodayHq(int jys)
{
    struct _stat buff;
    char tmp[10];
    
    _strdate(tmp);    
    _fstat(HqkData[jys].hf,&buff);
    
	return TRUE;
}



//if(_hread(HqkData[jys].hf, buffer, recCount*reclen) !=recCount*reclen)

#define	_hread	hRead
#define	PER_READ_LEN	1024L

long hRead(HFILE hf,char huge * buff,long len)
{                             
	long rlen=0;
	UINT ret,plen ;
	
	if(len<=PER_READ_LEN)
	{
		ret =_lread(hf,buff,(UINT)(len));
		rlen =(long)(ret);
	}
	else
	{
		rlen =0;
		do
		{
			if(len -rlen>=	PER_READ_LEN)
			{
				plen =(UINT)(PER_READ_LEN);
			}
			else
			{
				plen =(UINT)(len -rlen);
			}
			
			ret =_lread(hf,buff,plen);
			if(ret!=HFILE_ERROR)			
			{                   
				buff+=ret;
				rlen +=ret;
			}
			else
			{   
				return -1;
			}
		}while(rlen<len&&ret!=HFILE_ERROR);
	}
	
	return rlen;	
}

//////////////////////////////////////////////////////////////////
//功能		：初始化内存行情数据对象、内存买卖盘对象、内存分时数据头部信息 ，       
//          同时，填充相应的内存行情数据的股票名称字段， 三个内存对象与填充
//          操作以内存行情数据的记录号为主索引 ，所以当行情数据的记录数有变化
//          时，一定要更新其余的内存对象，并重作名称填充。该例程同时初始化大盘
//          内存对象和排行榜内存对象
//参数		：
//     		jys---交易所编码
//返回码	：
//			TRUE---成功
//          FALSE--失败
//修改日期	：1997/10/15
//修改建议	：可将内存行情数据放入BTREE，BTREE内包含其余的两内存数据对象，以股票
//			代码作索引


int ReadHqFirst(int jys)
{
	int i, j, reclen, headlen;
	long recCount,bytes;
	char huge*buffer;
	char huge *lpTmp;
	LPSTR lpFld;
	char tmp[100];
	static BOOL fFirst[2] ={TRUE, TRUE};
		
	if(HqkData[jys].hf <0)
	{ 
	  	ErrMsg(ghWndMain, "ReadHqFirst 不能打开行情库句柄!");
		return FALSE;
    }
	if(jys ==0) MsgLocal("读取深圳行情");
	else MsgLocal("读取上海行情");
	
	reclen=*(int *)HqkData[jys].dbfStruct.rlen;
	headlen=*(int *)HqkData[jys].dbfStruct.hlen;
	
	recCount =GetDbfRecCount(HqkData[jys].hf,headlen,reclen);
	//计算行情库有效记录	
	//recCount =GetValidRecNum(jys);	
	if(jys ==1)
	{
		recCount --;
	}
	if(recCount <=0) 
	{
		ErrMsg(ghWndMain, "ReadHqFirst 行情库记录数为零!");
		return FALSE;
	}
	// 分配内存，同时将分时数据结构等清零及初始化              
	if(HqAllocMem(jys, (int)recCount) <0) 
	{
		ErrMsg(ghWndMain, "ReadHqFirst:HqAllocMem错!");
		return FALSE;
	}
	//读交易所行情文件
	//reclen=*(int *)HqkData[jys].dbfStruct.rlen;
	//headlen=*(int *)HqkData[jys].dbfStruct.hlen;

	buffer =(char huge*)GlobalAllocPtr(GHND, recCount*reclen+1);
	if (buffer==NULL) 
	{
		ErrMsg(ghWndMain, "ReadHqFirst:alloc buffer 错!");
		return FALSE;
    }
	_llseek(HqkData[jys].hf,(long)headlen,SEEK_SET);
	if(jys ==1)
		_llseek(HqkData[jys].hf, reclen, SEEK_CUR);
		
	bytes =hRead(HqkData[jys].hf, buffer, recCount*reclen);
	
	if(bytes == -1)
	{
		ErrMsg(ghWndMain,"ReadHqFirst:hRead bytes =-1错");
		GlobalFreePtr(buffer);  
		return FALSE;
	} 
	
	if(bytes !=recCount*reclen)
	{
	 	ErrMsg(ghWndMain, "ReadHqFirst:bytes !=recCount*reclen");
	 	GlobalFreePtr(buffer);  
	 	return FALSE;
	}
	    
	//初始化行情数据结构    
	lpTmp =buffer;
	for (i=0;i<recCount;i++) 
	{
		for(j =0; j<HQ_FLDS_COUNT; j++)
		{
			lpFld =GetHqFldPos(jys, i, j);
			if(HqFldPoss[jys][j] >=0)
			{
				FldToString(lpTmp,
					(FieldStruct *)&HqkData[jys].fldStruct[HqFldPoss[jys][j]],
					tmp);
				switch(HqFldTypes[j])
				{
					case FLD_TYPE_STRING:
						strcpy(lpFld, tmp);
					break;
					case FLD_TYPE_FLOAT:
						*(float *)lpFld =(float)atof(tmp);
					break;
					case FLD_TYPE_LONG:
						*(long *)lpFld =(long)atol(tmp);
					break;
				}
			}
		}
		
		if(IsGuoZhai(jys, i))
			HqData[jys].lpRefData[i].cjss /=10;     //单位：手
		else
			HqData[jys].lpRefData[i].cjss /=100;    //单位：手
		HqData[jys].lpRefData[i].cjje /=1000;       //单位：万
		
		HqData[jys].lpRefData[i].lc =0;
		
		if(HqData[jys].lpPreData[i].zrsp ==0
			||HqData[jys].lpRefData[i].zjjg ==0)
			HqData[jys].lpRefData[i].zdf =0;
		else
			HqData[jys].lpRefData[i].zdf =
					(HqData[jys].lpRefData[i].zjjg
					- HqData[jys].lpPreData[i].zrsp)
					/HqData[jys].lpPreData[i].zrsp*100;
				
		if(IsZsRec(jys, i))
		{
			if(jys ==1)
			{
				GetShZsFirst(lpTmp, DpData[jys].recCount);
				DpData[jys].recCount++;
			}
		}
		
		if(jys ==1)
		{               
			FldToString(lpTmp,(FieldStruct *)&HqkData[jys].fldStruct[1],
				HqData[jys].lpPreData[i].zqmc);
			GetShMmp(TRUE, i, lpTmp);
		}
		lpTmp +=reclen;
	}
	 
	GlobalFreePtr(buffer);  
	CheckGraHead(jys);
	
	if(jys ==0)
	{
		if(!GetSzZqmc(jys)) 
		{
			ErrMsg(ghWndMain,"ReadHqFirst:GetSzZqmc(jys)错");
			return FALSE;
		}
		if(!ReadSzZsFirst()) 
		{
		    ErrMsg(ghWndMain,"ReadHqFirst:ReadSzZsFirst()错");
			return FALSE;
		}
		if(!ReadSzMmp(TRUE))		
		{
		    ErrMsg(ghWndMain,"ReadHqFirst:ReadSzZsFirst()错");
			return FALSE;
		}
	}

	i =GetMaxMin10(jys);
	if(i >0) SendMaxMin(jys, i);
	
	GetDpData(jys, TRUE);

	MsgLocal("OK.");
	fFirst[jys] =FALSE;