style.cpp

一个多线程

#include "stdafx.h"
#include "style.h"
#include "global.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

#define COMPILE_SHOW 1
//////////////////////////////////////////////////////////////////////
// CStyle Class
//////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
struct WORDTABLE styleWord[]=
{
	{"version",		WORD_VERION		},
	{"parentstyle",	WORD_PARENTSTYLE},
	{"variant",		WORD_VARIANT	},
	{"defcommand",	WORD_COMMAND	},
	{"defevent",	WORD_EVENT		},	
	{"int",			WORD_INT_TYPE	},
	{"float",		WORD_FLOAT_TYPE	},	
	{"dword",		WORD_DWORD_TYPE	},
	{"string",		WORD_STRING_TYPE},
	{"datablock",	WORD_HANDLE_TYPE},
	{"const",		WORD_CONST},
	{"#include",	WORD_INCLUDE},
	{"static",		WORD_STATIC}
};
CMapStringToPtr CStyle::m_StrStyleCommand(10);

CStyleMg gpStyleMg;

CStyle::CStyle(CFunctionRegister * pRegister,LPSTR lpStyleFile)
{
	m_pRegister=pRegister;
	if(m_pRegister)
		m_pRegister->m_pStyle=this;
	m_csFileName=lpStyleFile;
	m_pstkStyleWord=styleWord;
	m_pScanner=new CScanner(lpStyleFile);
	m_iuser=1;
	m_StyleStrTable.InitHashTable(30);
}

CStyle::~CStyle()
{
	int i;
	if(m_pRegister)
		m_pRegister->m_pStyle=NULL;
	for(i=0;i<m_ParamArray.GetSize();i++){
		PARAMEMTER & prm=m_ParamArray[i];
		if(prm.lpstrPreFix)
			UniVar::DeleteBlock(prm.lpstrPreFix);
	};
	for(i=0;i<m_ListConst.GetSize();i++){
		UniVar::DeleteBlock(m_ListConst[i].lpConst);
		UniVar::DeleteBlock(m_ListConst[i].lpName);
	}
	m_ListConst.RemoveAll();
	delete m_pScanner;
}

void WriteError(char * filename,int line,char * samp,char * error)
{
	if(COMPILE_SHOW){
		CString cs;
		cs.Format("line number:% 5ld: %s ,%s %s.",line+1,filename,samp,error);
		if(gDllGlobalManager.m_pGlobalApi)
			gDllGlobalManager.m_pGlobalApi->insertmessage((char *)(LPCTSTR)cs);
		return;
	}
}

void CStyle::AddSystemCommand(LPSTR lpCommand,DWORD dwCommandId,int ParamNum,UniVar * pParam)
{
	DWORD dwid;
	if(m_StyleStrTable.Lookup(lpCommand,(void *&)dwid)){
		WriteError(m_csFileName,m_icLine,lpCommand,"redefine key name");
		m_ierror++;
	}
	int k=m_ParamArray.GetSize();
	COMMANDSTRUCT scmd;
	scmd.dwCommandId=dwCommandId;
	scmd.ParamNum=ParamNum;
	for(int j=0;j<ParamNum;j++){
		PARAMEMTER prm;
		prm.tv=pParam[j*2];
		if(!pParam[j*2+1].IsEmpty()){
			prm.lpstrPreFix=UniVar::NewBlock(strlen(pParam[j*2+1].uv.cv)+1);
			strcpy(prm.lpstrPreFix,pParam[j*2+1].uv.cv);
		}
		else {
			prm.lpstrPreFix=NULL;
		}
		m_ParamArray.Add(prm);
	}
	scmd.iStartParam=k;
	m_CommandList.Add(scmd);
	m_StyleStrTable.SetAt(lpCommand,(void *)((dwCommandId&POSID_FILTER)+TYPE_COMMAND));
}

void CStyle::AddSystemVariant(LPSTR lpCommand,DWORD dwCommandId)
{
	DWORD dwid;
	if(m_StyleStrTable.Lookup(lpCommand,(void *&)dwid)){
		WriteError(m_csFileName,m_icLine,lpCommand,"redefine key name");
		m_ierror++;
	}
	m_StyleStrTable.SetAt(lpCommand,(void *)((dwCommandId&POSID_FILTER)+TYPE_VARIANT));
}

bool CStyle::AddStyle(char *filename)
{
	CStyle *pStyle;
	pStyle=new CStyle(NULL,filename);
	if(pStyle){
		if(!pStyle->GetStyle()){
			delete pStyle;
			pStyle=NULL;
			return false;
		}
		else{
			int j=0;
			int i;
			for(i=0;i<pStyle->m_ListConst.GetSize();i++){
				m_ListConst.Add(pStyle->m_ListConst[i]);
			}
			pStyle->m_ListConst.RemoveAll();
			j=m_ParamArray.GetSize();
			for(i=0;i<pStyle->m_ParamArray.GetSize();i++){
				m_ParamArray.Add(pStyle->m_ParamArray[i]);
				if(pStyle->m_ParamArray[i].lpstrPreFix){
					m_ParamArray[j+i].lpstrPreFix=UniVar::NewBlock(strlen(pStyle->m_ParamArray[i].lpstrPreFix)+1);
					strcpy(m_ParamArray[j+i].lpstrPreFix,pStyle->m_ParamArray[i].lpstrPreFix);
				}
				else{
					m_ParamArray[j+i].lpstrPreFix=NULL;
				}
			}
			int k=j;

			j=m_CommandList.GetSize();
			int l=m_UserEventList.GetSize();
			CString csStr;
			DWORD dwId,dwid;
			POSITION pos;
			pos=pStyle->m_StyleStrTable.GetStartPosition();
			int ip,jj,ll;
			jj=j;
			ll=l;
			while(pos){
				pStyle->m_StyleStrTable.GetNextAssoc(pos,csStr,(void *&)dwId);
				//lookup for redefine
				BOOL bError=FALSE;
				if(m_StyleStrTable.Lookup(csStr,(void *&)dwid)){
					WriteError(m_csFileName,m_icLine,(LPSTR)(LPCTSTR)csStr,"redefine key name");
					bError=TRUE;
					m_ierror++;
				}

				switch(dwId&ITYPE_FILTER){
				case TYPE_STATIC:
				case TYPE_VARIANT:
					if(!bError)
						m_StyleStrTable.SetAt(csStr,(void *)dwId);
					break;
				case TYPE_COMMAND:
					ip=dwId&POSID_FILTER;
					m_CommandList.Add(pStyle->m_CommandList[ip]);
					m_CommandList[jj].iStartParam+=k;
					if(!bError)
						m_StyleStrTable.SetAt(csStr,(void *)(jj+TYPE_COMMAND));
					jj+=1;
					break;
				case TYPE_EVENT:
					ip=dwId&POSID_FILTER;
					m_UserEventList.Add(pStyle->m_UserEventList[ip]);
					if(!bError)
						m_StyleStrTable.SetAt(csStr,(void *)(ll+TYPE_EVENT));
					ll+=1;
					break;
				}
			}
			delete pStyle;
			pStyle=NULL;
			return true;
		}
	}
	else {
		return false;
	}
}

BOOL CStyle::GetStyle()//bool bget
{
	if(!m_pScanner)return FALSE;
	m_icLine=0;
	m_ierror=0;
	while(ReadLine());
	if(m_csVersion.IsEmpty()){
		WriteError(m_csFileName,-1,"undefine version in style file","errors found");
		m_ierror++;
		return FALSE;
	}
	if(m_ierror){
		CString cs;
		cs.Format("%ld",m_ierror);
		WriteError(m_csFileName,-1,(LPSTR)(LPCTSTR)cs,"errors found");
	}
	if(m_ierror)return FALSE;
	return TRUE;
}

BOOL CStyle::ReadLine()
{
	ASSERT(m_pScanner);
	LPSTR pIdentyString;
	DWORD dwIdentyId,dwIdenty;
	char * pName;
	pIdentyString=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
	if(dwIdentyId==WORD_NOFILEOPENED){
		WriteError(pName,m_icLine,"CAN'T OPEN FILE","STYLE");
		m_ierror++;
		return FALSE;
	}
	if(dwIdentyId==WORD_ENDOFFILE)return FALSE;
	if(dwIdentyId==WORD_IDENTY||dwIdentyId==WORD_COMPILE){
		if(CStyle::m_StrStyleCommand.Lookup(pIdentyString,(void *&)dwIdenty)){
			int ii;
			switch(dwIdenty){
			case WORD_INCLUDE:
				{
					pIdentyString=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
					while(dwIdentyId!=WORD_ENDOFLINE&&dwIdentyId!=WORD_ENDOFFILE)
						m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
					if(pIdentyString){
						if(!m_pScanner->OpenSubScan(pIdentyString)){
							WriteError(pName,m_icLine,pIdentyString,"cant openfile");
							m_ierror++;
						}
					}
					else {
						WriteError(pName,m_icLine,pIdentyString,"file name  error");
						m_ierror++;
					}
				}
				break;
			case WORD_PARENTSTYLE:
				{
					pIdentyString=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
					if(pIdentyString){
						if(!AddStyle(pIdentyString)){
							WriteError(pName,m_icLine,pIdentyString,"load style file error");
							m_ierror++;
						}
					}
					else {
						WriteError(pName,m_icLine,pIdentyString,"style file name  error");
						m_ierror++;
					}
				}
				break;
			case WORD_VERION:
				m_csVersion=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
				if(dwIdentyId!=WORD_STRING){
					WriteError(pName,m_icLine,"version","unknown words");
					m_ierror++;
					m_csVersion="";
				}
				break;
			case WORD_STATIC:
				pIdentyString=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
				ii=strlen(pIdentyString);
				if(ii&&dwIdentyId==WORD_IDENTY){
					if(m_StyleStrTable.Lookup(pIdentyString,(void *&)dwIdentyId)){
						WriteError(pName,m_icLine,pIdentyString,"redefine key name");
						m_ierror++;
						break;
					}
					dwIdentyId=gpStyleMg.AddStaticVar(pIdentyString);
					if(dwIdentyId!=0xffffffff){
						m_StyleStrTable.SetAt(pIdentyString,(void *)dwIdentyId);
					}
				}
				break;
			case WORD_CONST:
				pIdentyString=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
				ii=strlen(pIdentyString);
				if(ii&&dwIdentyId==WORD_IDENTY){
					CString csstr=pIdentyString;
					if(m_StyleStrTable.Lookup(pIdentyString,(void *&)dwIdentyId)){
						WriteError(pName,m_icLine,pIdentyString,"redefine key name");
						m_ierror++;
						break;
					}
					pIdentyString=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
					if(dwIdentyId&0xf0!=0x30){
						WriteError(pName,m_icLine,pIdentyString,"error define const var");
						m_ierror++;
						break;
					}
					CONSTVAR cv;
					cv.lpConst=UniVar::NewBlock(strlen(pIdentyString)+1);
					strcpy(cv.lpConst,pIdentyString);
					cv.dwId=dwIdentyId;
					cv.lpName=UniVar::NewBlock(csstr.GetLength()+1);
					strcpy(cv.lpName,csstr);
					m_ListConst.Add(cv);
				}
				break;
			case WORD_VARIANT:
				pIdentyString=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
				ii=strlen(pIdentyString);
				if(ii&&dwIdentyId==WORD_IDENTY){
					CString csStr=pIdentyString;
					if(m_StyleStrTable.Lookup(pIdentyString,(void *&)dwIdentyId)){
						WriteError(pName,m_icLine,pIdentyString,"redefine key name");
						m_ierror++;
						break;
					}
					pIdentyString=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
					if(dwIdentyId!=WORD_UINT){
						WriteError(pName,m_icLine,pIdentyString,"unknown words");
						m_ierror++;
						break;
					}
					DWORD dwId;
					sscanf(pIdentyString,"%lx",&dwId);
					m_StyleStrTable.SetAt(csStr,(void *)((dwId&POSID_FILTER)+TYPE_VARIANT));
				}
				break;
			case WORD_COMMAND:
				pIdentyString=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
				ii=strlen(pIdentyString);
				if(ii&&dwIdentyId==WORD_IDENTY){
					if(m_StyleStrTable.Lookup(pIdentyString,(void *&)dwIdentyId)){
						WriteError(pName,m_icLine,pIdentyString,"redefine key name");
						m_ierror++;
						break;
					}
					COMMANDSTRUCT cmd;
					CString csnm=pIdentyString;
					pIdentyString=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
					if(dwIdentyId!=WORD_UINT){
						WriteError(pName,m_icLine,pIdentyString,"unknown words");
						m_ierror++;
						break;
					}
					sscanf(pIdentyString,"%lx",&cmd.dwCommandId);
					cmd.dwCommandId&=~ITYPE_FILTER;
					cmd.dwCommandId|=TYPE_COMMAND;
					cmd.ParamNum=0;
					cmd.iStartParam=0;
					cmd.pFn=NULL;
					int ierror=0;
					PARAMEMTER prm;
					while(1){
						prm.lpstrPreFix=NULL;
						pIdentyString=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
						if(pIdentyString[0]=='.'){
							pIdentyString=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
							if(pIdentyString[0]=='.'){
								pIdentyString=m_pScanner->ReadWord(pName,dwIdentyId,m_icLine);
								if(pIdentyString[0]=='.'){
									prm.lpstrPreFix=UniVar::NewBlock(4);
									strcpy(prm.lpstrPreFix,"...");
									prm.tv=0;
									prm.tv.inout=USE_TYPE_INOUT;
									m_ParamArray.Add(prm);
									cmd.ParamNum++;
									break;
								}
								else {
									WriteError(pName,m_icLine,pIdentyString,"unknown words");
									m_ierror++;
									ierror=1;
									break;