qianlong.cpp

股票软件

#include "stdafx.h"
#include "Database.h"
#include "SpString.h"
#include "QianLong.h"

//#include	<math.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

BOOL convert_QL_Data_5min_to_KDATA( DWORD dwMarket, const char *szCode, struct QL_Data_5min * pqlkd, KDATA *pkd )
{
	SP_ASSERT( pqlkd && pkd );
	if( NULL == pqlkd || NULL == pkd )
		return FALSE;
	memset( pkd, 0, sizeof(KDATA) );

	pkd->m_dwMarket	= dwMarket;
	if( szCode )
		strncpy( pkd->m_szCode, szCode, min(sizeof(pkd->m_szCode)-1,strlen(szCode)) );

	pkd->m_date		= pqlkd->min_off;
	CSPTime	sptime;
	if( sptime.FromStockTimeMin( pkd->m_date) )
		pkd->m_time	= sptime.GetTime();

	pkd->m_fOpen	= (float)fabs( pqlkd->open_price * 0.001 );
	pkd->m_fHigh	= (float)fabs( pqlkd->high_price * 0.001 );
	pkd->m_fLow		= (float)fabs( pqlkd->low_price * 0.001 );
	pkd->m_fClose	= (float)fabs( pqlkd->close_price * 0.001 );
	pkd->m_fVolume	= (float)fabs( pqlkd->min_volume * 100. );
	pkd->m_fAmount	= (float)fabs( pqlkd->min_amount * 100. );
	return TRUE;
}

BOOL convert_QL_Data_day_to_KDATA( DWORD dwMarket, const char *szCode, struct QL_Data_day * pqlkd, KDATA *pkd )
{
	SP_ASSERT( pqlkd && pkd );
	if( NULL == pqlkd || NULL == pkd )
		return FALSE;
	memset( pkd, 0, sizeof(KDATA) );

	pkd->m_dwMarket	= dwMarket;
	if( szCode )
		strncpy( pkd->m_szCode, szCode, min(sizeof(pkd->m_szCode)-1,strlen(szCode)) );

	pkd->m_date		= pqlkd->day_date;
	CSPTime	sptime;
	if( sptime.FromStockTimeDay(pkd->m_date) )
		pkd->m_time	= sptime.GetTime();

	pkd->m_fOpen	= (float)fabs( pqlkd->open_price * 0.001 );
	pkd->m_fHigh	= (float)fabs( pqlkd->high_price * 0.001 );
	pkd->m_fLow		= (float)fabs( pqlkd->low_price * 0.001 );
	pkd->m_fClose	= (float)fabs( pqlkd->close_price * 0.001 );
	pkd->m_fVolume	= (float)fabs( pqlkd->day_volume * 100. );
	pkd->m_fAmount	= (float)fabs( pqlkd->day_amount * 1000. );
	return TRUE;
}

BOOL convert_KDATA_to_QL_Data_day( KDATA * pkd, struct QL_Data_day * pqlkd )
{
	SP_ASSERT( pqlkd && pkd );
	if( NULL == pqlkd || NULL == pkd )
		return FALSE;
	memset( pqlkd, 0, sizeof(struct QL_Data_day) );

	pqlkd->day_date		= (DWORD)( pkd->m_date );
	pqlkd->open_price	= (DWORD)( pkd->m_fOpen * 1000 );
	pqlkd->high_price	= (DWORD)( pkd->m_fHigh * 1000 );
	pqlkd->low_price	= (DWORD)( pkd->m_fLow * 1000 );
	pqlkd->close_price	= (DWORD)( pkd->m_fClose * 1000 );
	pqlkd->day_volume	= (DWORD)( pkd->m_fVolume * 0.01 );
	pqlkd->day_amount	= (DWORD)( pkd->m_fAmount * 0.001 );
	return TRUE;
}

BOOL convert_KDATA_to_QL_Data_5min( KDATA * pkd, struct QL_Data_5min * pqlkd )
{
	SP_ASSERT( pqlkd && pkd );
	if( NULL == pqlkd || NULL == pkd )
		return FALSE;
	memset( pqlkd, 0, sizeof(struct QL_Data_day) );

	pqlkd->min_off		= (DWORD)( pkd->m_date );
	pqlkd->open_price	= (DWORD)( pkd->m_fOpen * 1000 );
	pqlkd->high_price	= (DWORD)( pkd->m_fHigh * 1000 );
	pqlkd->low_price	= (DWORD)( pkd->m_fLow * 1000 );
	pqlkd->close_price	= (DWORD)( pkd->m_fClose * 1000 );
	pqlkd->min_volume	= (DWORD)( pkd->m_fVolume * 0.01 );
	pqlkd->min_amount	= (DWORD)( pkd->m_fAmount * 0.01 );
	return TRUE;
}

void ConvertQLStockInfo( DWORD dwMarket, QL_Stock_info_V302 & block, CStockInfo *pInfo )
{
	pInfo->Clear();

	char	code[sizeof(block.stock_code)+2];
	memset(code,0,sizeof(code));
	strncpy(code,(const char *)block.stock_code,sizeof(block.stock_code));

	char	name[sizeof(block.stock_name)+2];
	memset(name,0,sizeof(name));
	strncpy(name,(const char *)block.stock_name,sizeof(block.stock_name));

	pInfo->SetStockCode( dwMarket, code );
	pInfo->SetStockName( name );
	pInfo->SetType( block.stock_type );

/*
	pInfo->m_fLast		= (float)fabs( block.last_close_price * 0.001 );
	pInfo->m_fOpen		= (float)fabs( block.open_price * 0.001 );
	pInfo->m_fHigh		= (float)fabs( block.high_price * 0.001 );
	pInfo->m_fLow		= (float)fabs( block.low_price * 0.001 );
	pInfo->m_fClose		= (float)fabs( block.close_price * 0.001 );
	pInfo->m_fVolume	= (float)fabs( block.total_volume * 100. );
	pInfo->m_fAmount	= (float)fabs( block.total_value * 1000. );
	pInfo->m_fBuyPrice[0]	= (float)fabs( block.buy_1_price * 0.001 );
	pInfo->m_fBuyVolume[0]	= (float)fabs( block.buy_1_volume * 100. );
	pInfo->m_fBuyPrice[1]	= (float)fabs( block.buy_2_price * 0.001 );
	pInfo->m_fBuyVolume[1]	= (float)fabs( block.buy_2_volume * 100. );
	pInfo->m_fBuyPrice[2]	= (float)fabs( block.buy_3_price * 0.001 );
	pInfo->m_fBuyVolume[2]	= (float)fabs( block.buy_3_volume * 100. );
	pInfo->m_fSellPrice[0]	= (float)fabs( block.sell_1_price * 0.001 );
	pInfo->m_fSellVolume[0]	= (float)fabs( block.sell_1_volume * 100. );
	pInfo->m_fSellPrice[1]	= (float)fabs( block.sell_2_price * 0.001 );
	pInfo->m_fSellVolume[1]	= (float)fabs( block.sell_2_volume * 100. );
	pInfo->m_fSellPrice[2]	= (float)fabs( block.sell_3_price * 0.001 );
	pInfo->m_fSellVolume[2]	= (float)fabs( block.sell_3_volume * 100. );
*/
}

void ConvertQLStockInfo( DWORD dwMarket, QL_Stock_info2_V304 & block, CStockInfo *pInfo )
{
	pInfo->Clear();

	char	code[sizeof(block.stock_code)+2];
	memset(code,0,sizeof(code));
	strncpy(code,(const char *)block.stock_code,sizeof(block.stock_code));

	char	name[sizeof(block.stock_name)+2];
	memset(name,0,sizeof(name));
	strncpy(name,(const char *)block.stock_name,sizeof(block.stock_name));

	pInfo->SetStockCode( dwMarket, code );
	pInfo->SetStockName( name );
	pInfo->SetType( block.stock_type );

/*
	pInfo->m_fLast		= (float)fabs( block.last_close_price * 0.001 );
	pInfo->m_fOpen		= (float)fabs( block.open_price * 0.001 );
	pInfo->m_fHigh		= (float)fabs( block.high_price * 0.001 );
	pInfo->m_fLow		= (float)fabs( block.low_price * 0.001 );
	pInfo->m_fClose		= (float)fabs( block.close_price * 0.001 );
	pInfo->m_fVolume	= (float)fabs( block.total_volume * 100. );
	pInfo->m_fAmount	= (float)fabs( block.total_value * 1000. );
	pInfo->m_fBuyPrice[0]	= (float)fabs( block.buy_1_price * 0.001 );
	pInfo->m_fBuyVolume[0]	= (float)fabs( block.buy_1_volume * 100. );
	pInfo->m_fBuyPrice[1]	= (float)fabs( block.buy_2_price * 0.001 );
	pInfo->m_fBuyVolume[1]	= (float)fabs( block.buy_2_volume * 100. );
	pInfo->m_fBuyPrice[2]	= (float)fabs( block.buy_3_price * 0.001 );
	pInfo->m_fBuyVolume[2]	= (float)fabs( block.buy_3_volume * 100. );
	pInfo->m_fSellPrice[0]	= (float)fabs( block.sell_1_price * 0.001 );
	pInfo->m_fSellVolume[0]	= (float)fabs( block.sell_1_volume * 100. );
	pInfo->m_fSellPrice[1]	= (float)fabs( block.sell_2_price * 0.001 );
	pInfo->m_fSellVolume[1]	= (float)fabs( block.sell_2_volume * 100. );
	pInfo->m_fSellPrice[2]	= (float)fabs( block.sell_3_price * 0.001 );
	pInfo->m_fSellVolume[2]	= (float)fabs( block.sell_3_volume * 100. );
*/
}

/////////////////////////////////////////////////////////////////////////////////////
// class	CQianlong
/*

struct QL_Info_data datainfo_sha[TYPE_NUM];
struct QL_Info_data datainfo_szn[TYPE_NUM];

unsigned char exepath[80];
unsigned char appdexe[88];

unsigned char ml_sys[80];
unsigned char ml_dat[80];
unsigned char ml_sh_day[80];
unsigned char ml_sz_day[80];
unsigned char ml_sh_min[80];
unsigned char ml_sz_min[80];
unsigned char ml_sh_wek[80];
unsigned char ml_sz_wek[80];
unsigned char ml_sh_mnt[80];
unsigned char ml_sz_mnt[80];

unsigned char sl_sys[80];
unsigned char sl_dat[80];
unsigned char sl_sh_day[80];
unsigned char sl_sz_day[80];
unsigned char sl_sh_min[80];
unsigned char sl_sz_min[80];
unsigned char sl_sh_wek[80];
unsigned char sl_sz_wek[80];
unsigned char sl_sh_mnt[80];
unsigned char sl_sz_mnt[80];

unsigned char hx_sys[80];
unsigned char hx_dat[80];
unsigned char hx_sh_day[80];
unsigned char hx_sz_day[80];
unsigned char hx_sh_min[80];
unsigned char hx_sz_min[80];
unsigned char hx_sh_wek[80];
unsigned char hx_sz_wek[80];
unsigned char hx_sh_mnt[80];
unsigned char hx_sz_mnt[80];

unsigned char dealpath[80];
unsigned char dealdat[80];
unsigned char tmpdir[80];
unsigned char sysdir[80];
unsigned char infdir[80];
unsigned char datdir[80];
unsigned char basdir[80];
unsigned char flag_mlv304;

unsigned long nowdate;
unsigned char datestr[10];
unsigned char flag_dynamic;
unsigned char ml30_flag;
unsigned char slon_flag;
unsigned char hxtw_flag;
*/

char ml_dat[]			= "data\\";
char ml_sh_info[]		= "data\\shinfo.dat";
char ml_sz_info[]		= "data\\szinfo.dat";
char ml_sh_now[]		= "data\\shnow.dat";
char ml_sz_now[]		= "data\\sznow.dat";
char ml_sh_pyjc[]		= "data\\shpyjc.dat";
char ml_sz_pyjc[]		= "data\\szpyjc.dat";
char ml_sh_trace[]		= "data\\shtrace.dat";
char ml_sz_trace[]		= "data\\sztrace.dat";
char ml_sh_minute[]		= "data\\shminute.dat";
char ml_sz_minute[]		= "data\\szminute.dat";

char ml_data[]			= "data\\";
char ml_sh[]			= "data\\sh\\";
char ml_sz[]			= "data\\sz\\";
char ml_base[]			= "bas\\";
char ml_month[]			= "mon\\";
char ml_week[]			= "wek\\";
char ml_day[]			= "day\\";
char ml_min5[]			= "nmn\\";

char ml_sh_base[]		= "data\\sh\\bas\\";
char ml_sz_base[]		= "data\\sz\\bas\\";
char ml_sh_month[]		= "data\\sh\\mon\\";
char ml_sz_month[]		= "data\\sz\\mon\\";
char ml_sh_week[]		= "data\\sh\\wek\\";
char ml_sz_week[]		= "data\\sz\\wek\\";
char ml_sh_day[]		= "data\\sh\\day\\";
char ml_sz_day[]		= "data\\sz\\day\\";
char ml_sh_min[]		= "data\\sh\\nmn\\";
char ml_sz_min[]		= "data\\sz\\nmn\\";

char ml_ext_base[]		= ".txt";
char ml_ext_month[]		= ".mnt";
char ml_ext_week[]		= ".wek";
char ml_ext_day[]		= ".day";
char ml_ext_min5[]		= ".nmn";

CQianlong::CQianlong( const char * rootpath, BOOL bOK )
{
	m_bIsOK	= FALSE;
	memset( m_szRootPath, 0, sizeof(m_szRootPath) );
	if( !bOK )
	{
		if( GetAccurateRoot( rootpath, m_szRootPath, sizeof(m_szRootPath)-1 ) )
			m_bIsOK	= TRUE;
		else
			m_bIsOK	= FALSE;
	}
	else
	{
		strncpy( m_szRootPath, rootpath, sizeof(m_szRootPath)-1 );
		m_bIsOK	= TRUE;
	}

	m_nVersion	= versionUnknown;
	if( bOK )
		m_nVersion	= DetectVersion( GetRootPath() );
}

CQianlong::~CQianlong( )
{
}

int	CQianlong::GetMaxStockNumber( )
{
	SP_ASSERT( m_bIsOK );
	if( ! m_bIsOK )	return 0;

	// load shinfo.dat szinfo.dat

	int	blocksize	= sizeof(struct QL_Stock_info_V302);
	if( version304 == m_nVersion )
		blocksize	= sizeof(struct QL_Stock_info2_V304);

	DWORD	dwCount	= 0;
	CSPString	sFileName	= GetRootPath();
	sFileName	+= ml_sh_now;
	CSPFile	file;
	if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
	{
		DWORD dwFileLen = file.GetLength();
		dwCount	+= dwFileLen / blocksize;
		file.Close();
	}
	sFileName	= GetRootPath();
	sFileName	+= ml_sz_now;
	if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
	{
		DWORD dwFileLen = file.GetLength();
		dwCount	+= dwFileLen / blocksize;
		file.Close();
	}
	return	dwCount;
}

int	CQianlong::LoadCodetable( CStockContainer & container )
{
	SP_ASSERT( m_bIsOK );
	if( !m_bIsOK )	return 0;

	int maxsize = GetMaxStockNumber();
	container.SetSize( maxsize );
	CStockInfo * pdata = container.GetData();

	char	szShortName[QL_SHORTNAME_LEN+1];
	memset( szShortName, 0, sizeof(szShortName) );
	int	 nCount	= 0;
	CSPString	sFileName	= GetRootPath();
	sFileName	+= ml_sh_now;
	CSPFile	file;
	if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
	{
		// pin yin file
		CSPString	sFileNamePyjc	= GetRootPath();
		sFileNamePyjc	+= ml_sh_pyjc;
		CSPFile	filePyjc;
		filePyjc.Open( sFileNamePyjc, CSPFile::modeRead | CSPFile::shareDenyNone );
		
		if( version302 == m_nVersion )
		{
			struct QL_Stock_info_V302	block;
			while( nCount < maxsize 
					&& sizeof(block) == file.Read( &block, sizeof(block) ) )
			{
				pdata[nCount].Clear();
				ConvertQLStockInfo( CStock::marketSHSE, block, &(pdata[nCount]) );

				// read shortname
				if( CSPFile::hFileNull != filePyjc.m_hFile && QL_SHORTNAME_LEN == filePyjc.Read( szShortName, QL_SHORTNAME_LEN ) )
					pdata[nCount].SetStockShortName( szShortName );

				nCount	++;
			}
		}
		else if( version304 == m_nVersion )
		{
			struct QL_Stock_info2_V304	block;
			while( nCount < maxsize 
					&& sizeof(block) == file.Read( &block, sizeof(block) ) )
			{
				pdata[nCount].Clear();
				ConvertQLStockInfo( CStock::marketSHSE, block, &(pdata[nCount]) );

				// read shortname
				if( CSPFile::hFileNull != filePyjc.m_hFile && QL_SHORTNAME_LEN == filePyjc.Read( szShortName, QL_SHORTNAME_LEN ) )
					pdata[nCount].SetStockShortName( szShortName );

				nCount	++;
			}
		}

		if( CSPFile::hFileNull != filePyjc.m_hFile )
			filePyjc.Close();
		file.Close();
	}

	sFileName	= GetRootPath();
	sFileName	+= ml_sz_now;
	if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )