userctrl.cpp

一个多线程

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

#define MYASSERT(f) if(!(f))throw 0x7ffffffe
//////////////////////////////////////////////////////////////////////
// CUserControl Class
//////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CUserControl::CUserControl()
{
	m_pThis=this;
	m_pFlow=NULL;
	m_pControl=NULL;
	m_csFlowName="";
	m_bBoolCanTrace=FALSE;
}

CUserControl::~CUserControl()
{
	m_pThis=NULL;
	if(m_bBoolCanTrace){
		if(gDllGlobalManager.m_pGlobalApi){
			gDllGlobalManager.m_pGlobalApi->CancelTraceFlow(this);
		}
	}
	CFlowControl * pc=m_pControl;
	if(m_pControl){
		m_pControl=NULL;
		delete pc;
	}
}

BOOL CUserControl::CreateFlow(LPSTR lpFlowFile,DWORD dwId)
{
	if(!m_pBus)return FALSE;
	if(m_btIsPointed==0||m_pBus->m_pRoad[m_btPointRoad]->IsValid())
		PointeRoad((BYTE)m_pBus->m_iFlowRoad);
	m_csFlowName=lpFlowFile; 
	if(m_pControl)delete m_pControl;
	m_pControl=new CFlowControl(lpFlowFile,this,this,dwId);
	if(!m_pFlow){
		if(m_pControl)
			delete m_pControl;
		m_pControl=NULL;
	}
	if(m_pControl){
		if(m_bBoolCanTrace){
			if(gDllGlobalManager.m_pGlobalApi){
				gDllGlobalManager.m_pGlobalApi->CanTraceFlow(this);
			}
		}
		return TRUE;
	}
	return FALSE;
}

BOOL CUserControl::CreateFlow(DWORD dwFlowId)
{
	if(!m_pBus)return FALSE;
	if(m_btIsPointed==0||m_pBus->m_pRoad[m_btPointRoad]->IsValid())
		PointeRoad((BYTE)m_pBus->m_iFlowRoad);
	m_csFlowName.Format("%ld",dwFlowId); 
	if(m_pControl)delete m_pControl;
	m_pControl=new CFlowControl(NULL,this,this,dwFlowId);
	if(!m_pFlow){
		if(m_pControl)
			delete m_pControl;
		m_pControl=NULL;
	}
	if(m_pControl){
		if(m_bBoolCanTrace){
			if(gDllGlobalManager.m_pGlobalApi){
				gDllGlobalManager.m_pGlobalApi->CanTraceFlow(this);
			}
		}
		return TRUE;
	}
	return FALSE;
}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CFlowControl::CFlowControl(LPSTR lpFlowFile,CUserControl * pUserControl,CFunctionRegister * pRegister,DWORD dwId)
{
	m_pUserFlow=CUserFlow::GetFlow(pRegister,lpFlowFile,dwId);
	ASSERT(pUserControl);
	m_pUserControl=pUserControl;
	m_pUserControl->SetControl(m_pUserFlow);
	if(m_pUserFlow){
		m_GlobalValue.SetSize(m_pUserFlow->dwGlobalVarNum);
		if(m_pUserFlow->dwGlobalVarNum)
			memset(&m_GlobalValue[0],0,sizeof(UniVar)*m_pUserFlow->dwGlobalVarNum);
	}
	m_pPerBNode=NULL;
	m_CallSt.iCurrent=-1;
	m_CallSt.isProcessStatus=-1;
	m_CallSt.pdwCrerentLine=NULL;
	m_CallSt.m_pPrivateVarrent=NULL;
	pdwCrerentLine=NULL;
	m_CallSt.iParamStart=0;
	m_CallSt.pt.pOt=NULL;
	m_ParamList.SetSize(100);
	memset(&m_ParamList[0],0,sizeof(UniVar)*100);
	m_iRound=0;
	m_bStop=FALSE;
	m_bStart=0;
	m_RunData.SetSize(50);iPop=-1;
	m_Status=FLOW_IDLE;
	m_bDebug=FALSE;
	m_bFunctionBreak=false;
}

CFlowControl::~CFlowControl()
{
	CUserControl * pc=m_pUserControl;
	if(m_Status!=FLOW_IDLE){
		m_bStop=TRUE;
		if(m_pUserControl)
			m_pUserControl->EndTask(200);
	}
	if(pc==m_pUserControl){
		for(int i=0;i<m_GlobalValue.GetSize();i++)
			m_GlobalValue[i]=0;
		if(m_pUserControl)
			m_pUserControl->ClearFlow();
		while(1){
			if(m_CallSt.m_pPrivateVarrent){
				for(int j=0;j<(int)m_CallSt.pt.pFun->dwVarNum;j++){
					if(m_CallSt.m_pPrivateVarrent[j].GetDataLength()){
						m_CallSt.m_pPrivateVarrent[j]=0;
					}
				}
				UniVar::DeleteBlock(m_CallSt.m_pPrivateVarrent);
			}
			if(!m_pCallStack.Pop(m_CallSt))break;
		}
		m_CallSt.m_pPrivateVarrent=NULL;
		m_Status=FLOW_IDLE;	
	}
}

BOOL CFlowControl::GetDataValue(DWORD dwID,UniVar & tv)
{	
	switch(dwID&ITYPE_FILTER){
	case TYPE_CONST:	return m_pUserFlow->GetConst(dwID,tv);
	case TYPE_VARIANT:	return m_pUserControl->GetVarValue(dwID&POSID_FILTER,tv);
	case TYPE_STATIC:	return gpStyleMg.GetStaVar(dwID,tv);
	case TYPE_GLOBALVAR:	tv=m_GlobalValue[dwID&POSID_FILTER];return TRUE;
	case TYPE_LOCALVAR:		tv=m_CallSt.m_pPrivateVarrent[dwID&POSID_FILTER];return TRUE;
	}
	return FALSE;
}

BOOL CFlowControl::WaitForEnd(DWORD dwTime)
{
	DWORD dwStart=0;
	while(m_bStart==1&&dwStart<dwTime){
		if(dwTime!=0xffffffff)
			dwStart+=20;
		Sleep(20);
	}
	return (m_bStart!=1);
}

BOOL CFlowControl::SetDataValue(DWORD dwID,UniVar & tv)
{	
	switch(dwID&ITYPE_FILTER){
	case TYPE_VARIANT: return m_pUserControl->SetVarValue(dwID&POSID_FILTER,tv);
	case TYPE_STATIC: return gpStyleMg.SetStaVar(dwID,tv);
	case TYPE_GLOBALVAR: m_GlobalValue[dwID&POSID_FILTER]=tv;return TRUE;
	case TYPE_LOCALVAR: m_CallSt.m_pPrivateVarrent[dwID&POSID_FILTER]=tv;return TRUE;
	}
	return FALSE;
}

COMMANDRESULT CFlowControl::DefaultParse(DWORD dwCommand,UniVar * pdwCommandList,int iVarNum)
{
	try {
		return m_pUserControl->DefaultParse(dwCommand&POSID_FILTER,pdwCommandList,iVarNum);
	}
	catch(...){
		//log
		TRACE("flow exception cmd:%lx,param :%ld,%s\n",dwCommand,iVarNum,(LPSTR)(LPCTSTR)this->m_pUserFlow->m_csFileName);
		if(pdwCrerentLine)
			if(gDllGlobalManager.m_pGlobalApi)
				gDllGlobalManager.m_pGlobalApi->GLogEvent(exceptionLog,pdwCrerentLine[0],0,(LPSTR)(LPCTSTR)this->m_pUserFlow->m_csFileName ,"except.txt");
		return LINE_CONTINUE;
	}
}

COMMANDRESULT CFlowControl::RunLine(DWORD * pLine)
{
	if(!m_pUserFlow)return LINE_END;
	if(!m_pUserControl)
		return LINE_END;
	pun.pVoid=m_pUserFlow->GetStructFromId(pLine[0]);
	if(!pun.pVoid)
		return LINE_END;
	m_CallSt.pun=pun;
	switch(pLine[0]&ITYPE_FILTER){
	case TYPE_BNODE:
		{
			if(m_pPerBNode!=pun.pbn){
				if(m_pPerBNode)
					m_pPerBNode->dwOutTimes++;
				m_ListBNRoute.Add(pun.pbn);
				if(m_ListBNRoute.GetSize()>3000){
					m_ListBNRoute.RemoveAt(0);
				}
				m_pPerBNode=pun.pbn;
				pun.pbn->dwInTimes++;
			}
		}
		return LINE_CONTINUE;
	case TYPE_COMMAND:
		{
			COMMANDRESULT mst;
			if(pun.pcmd->ParamNum<1){
				m_CallSt.cNumOfParam=0;
				if(pun.pcmd->pFn){
					return pun.pcmd->pFn(NULL,0);
				}
				else {
					return DefaultParse(pun.pcmd->dwCommandId,NULL,0);
				}
			}
			else {
				m_CallSt.cNumOfParam=pun.pcmd->ParamNum;
				bool bAllSet=true;
				PARAMEMTER * pAram=&m_pUserFlow->m_pStyle->m_ParamArray[pun.pcmd->iStartParam+m_CallSt.cNumOfParam-1];
				if(pAram->lpstrPreFix&&!strcmp(pAram->lpstrPreFix,"...")){
					bAllSet=false;
					m_CallSt.cNumOfParam=0;
					while(pLine[m_CallSt.cNumOfParam+1]!=WORD_ENDOFLINE)m_CallSt.cNumOfParam++;
				}
				int ii=m_CallSt.cNumOfParam+m_CallSt.iParamStart;
				if(ii>m_ParamList.GetSize())m_ParamList.SetSize(ii);
				MYASSERT(m_CallSt.iParamStart>=0);
				UniVar tv;
				for(ii=0;ii<m_CallSt.cNumOfParam;ii++){
					if(ii<pun.pcmd->ParamNum-1){
						tv=Calculate(pLine[ii+1]);
						m_ParamList[ii+m_CallSt.iParamStart].SetData(&m_pUserFlow->m_pStyle->m_ParamArray[pun.pcmd->iStartParam+ii],tv);
					}
					else {
						if(bAllSet){
							tv=Calculate(pLine[ii+1]);
							m_ParamList[ii+m_CallSt.iParamStart].SetData(&m_pUserFlow->m_pStyle->m_ParamArray[pun.pcmd->iStartParam+ii],tv);
						}
						else{
							m_ParamList[ii+m_CallSt.iParamStart]=Calculate(pLine[ii+1]);
						}
					}
				}
				if(pun.pcmd->pFn){
					mst=pun.pcmd->pFn(&m_ParamList[m_CallSt.iParamStart],m_CallSt.cNumOfParam);
				}
				else {
					mst=DefaultParse(pun.pcmd->dwCommandId,&m_ParamList[m_CallSt.iParamStart],m_CallSt.cNumOfParam);
				}
				if(mst==LINE_PAUSE)
					return LINE_PAUSE;
				else if(mst==LINE_END)
					return LINE_END;
				PARAMEMTER * pAm=&m_pUserFlow->m_pStyle->m_ParamArray[pun.pcmd->iStartParam];
				for(ii=0;ii<m_CallSt.cNumOfParam;ii++){
					if(ii<pun.pcmd->ParamNum){
						if(pAm[ii].tv.inout==USE_TYPE_INOUT){
							SetDataValue(pLine[ii+1],m_ParamList[ii+m_CallSt.iParamStart]);
						}
					}
					else {
						SetDataValue(pLine[ii+1],m_ParamList[ii+m_CallSt.iParamStart]);
					}
					m_ParamList[ii+m_CallSt.iParamStart]=0;
				}
				return mst;
			}
		}
		break;
	case TYPE_FUNCTION:
		{
			UniVar * pVar=NULL,tv;
			if(pun.pfun->dwVarNum){
				pVar=(UniVar *)UniVar::NewBlock(sizeof(UniVar)*pun.pfun->dwVarNum);
				memset(pVar,0,sizeof(UniVar)*pun.pfun->dwVarNum);
				for(int ii=0;ii<pun.pfun->ParamNum;ii++){
					if(ii<pun.pfun->ParamNum){
						tv=Calculate(pLine[ii+1]);
						pVar[ii].SetData(&m_pUserFlow->m_ParamArray[pun.pfun->iStartParam+ii],tv);
					}
					else break;
				}
			}
			m_CallSt.pdwCrerentLine=pLine+1;
			m_pCallStack.Push(m_CallSt);
			m_CallSt.pt.pFun=pun.pfun;
			m_CallSt.iType=CALL_FUNC;
			m_CallSt.pdwCrerentLine=pLine+1;
			m_CallSt.iCurrent=pun.pfun->iStart;
			m_CallSt.m_pPrivateVarrent=pVar;
			return LINE_JUMP;
		}
		break;
	case TYPE_SYSTEM:
		switch(pLine[0]){
		case WORD_RESET:
			{
				if(m_ListBNRoute.GetSize()>=1){
					while(1){
						if(m_CallSt.iType==CALL_EVENT){
							UniVar up1=m_CallSt.m_pPrivateVarrent[0];
							UniVar up2=m_CallSt.m_pPrivateVarrent[1];
							DWORD dwId=m_CallSt.pt.pEv->pstkEvent->dwUserEventId;
							if(m_CallSt.m_pPrivateVarrent){
								for(int j=0;j<(int)m_CallSt.pt.pFun->dwVarNum;j++){
									if(m_CallSt.m_pPrivateVarrent[j].GetDataLength()){
										m_CallSt.m_pPrivateVarrent[j]=0;
									}
								}
								UniVar::DeleteBlock(m_CallSt.m_pPrivateVarrent);
							}
							m_pCallStack.Pop(m_CallSt);
							EventCallOver(-1,dwId,up1,up2);
						}
						else if(m_CallSt.iType==CALL_MAIN)break;
						else {
							if(m_CallSt.m_pPrivateVarrent){
								for(int j=0;j<(int)m_CallSt.pt.pFun->dwVarNum;j++){
									if(m_CallSt.m_pPrivateVarrent[j].GetDataLength()){
										m_CallSt.m_pPrivateVarrent[j]=0;
									}
								}
								UniVar::DeleteBlock(m_CallSt.m_pPrivateVarrent);
							}
							m_pCallStack.Pop(m_CallSt);
						}
					}
					m_CallSt.iCurrent=m_ListBNRoute[m_ListBNRoute.GetSize()-1]->dwLabel;
					return LINE_JUMP;
				}
				else {
					return LINE_CONTINUE;
				}
			}
		case WORD_BACK:
			{
				if(m_ListBNRoute.GetSize()>=2){
					m_pPerBNode=m_ListBNRoute[m_ListBNRoute.GetSize()-1];
					m_ListBNRoute.RemoveAt(m_ListBNRoute.GetSize()-1);
					while(1){
						if(m_CallSt.iType==CALL_EVENT){
							UniVar up1=m_CallSt.m_pPrivateVarrent[0];
							UniVar up2=m_CallSt.m_pPrivateVarrent[1];
							DWORD dwId=m_CallSt.pt.pEv->pstkEvent->dwUserEventId;
							if(m_CallSt.m_pPrivateVarrent){
								for(int j=0;j<(int)m_CallSt.pt.pFun->dwVarNum;j++){
									if(m_CallSt.m_pPrivateVarrent[j].GetDataLength()){
										m_CallSt.m_pPrivateVarrent[j]=0;
									}
								}
								UniVar::DeleteBlock(m_CallSt.m_pPrivateVarrent);
							}
							m_pCallStack.Pop(m_CallSt);
							EventCallOver(-1,dwId,up1,up2);
						}
						else if(m_CallSt.iType==CALL_MAIN)break;
						else {
							if(m_CallSt.m_pPrivateVarrent){
								for(int j=0;j<(int)m_CallSt.pt.pFun->dwVarNum;j++){
									if(m_CallSt.m_pPrivateVarrent[j].GetDataLength()){
										m_CallSt.m_pPrivateVarrent[j]=0;
									}
								}
								UniVar::DeleteBlock(m_CallSt.m_pPrivateVarrent);
							}
							m_pCallStack.Pop(m_CallSt);
						}
					}
					m_CallSt.iCurrent=m_ListBNRoute[m_ListBNRoute.GetSize()-1]->dwLabel;
					return LINE_JUMP;
				}
				else if(m_ListBNRoute.GetSize()==1){
					m_pPerBNode=m_ListBNRoute[m_ListBNRoute.GetSize()-1];
					return LINE_CONTINUE;
				}
				else{
					m_pPerBNode=NULL;
					return LINE_CONTINUE;
				}
				m_CallSt.iCurrent=pun.pbn->dwLabel;
				return LINE_JUMP;
			}
			break;
		case WORD_JUMP:
			{
				pun.pVoid=m_pUserFlow->GetStructFromId(pLine[1]);
				if(!pun.pVoid)return LINE_END;
				if(pLine[1]&ITYPE_FILTER!=TYPE_BNODE){
					UniVar tv=Calculate(pLine[1]);
					if(!tv.IsString()||tv.IsEmpty())return LINE_CONTINUE;
					pun.pbn=m_pUserFlow->GetBusinessNode((LPSTR)tv);
					if(!pun.pVoid)return LINE_CONTINUE;
				}
				while(1){
					if(m_CallSt.iType==CALL_EVENT){
						UniVar up1=m_CallSt.m_pPrivateVarrent[0];
						UniVar up2=m_CallSt.m_pPrivateVarrent[1];
						DWORD dwId=m_CallSt.pt.pEv->pstkEvent->dwUserEventId;
						if(m_CallSt.m_pPrivateVarrent){
							for(int j=0;j<(int)m_CallSt.pt.pFun->dwVarNum;j++){
								if(m_CallSt.m_pPrivateVarrent[j].GetDataLength()){
									m_CallSt.m_pPrivateVarrent[j]=0;
								}
							}
							UniVar::DeleteBlock(m_CallSt.m_pPrivateVarrent);
						}
						m_pCallStack.Pop(m_CallSt);
						EventCallOver(-1,dwId,up1,up2);
					}
					else if(m_CallSt.iType==CALL_MAIN)break;
					else {
						if(m_CallSt.m_pPrivateVarrent){
							for(int j=0;j<(int)m_CallSt.pt.pFun->dwVarNum;j++){
								if(m_CallSt.m_pPrivateVarrent[j].GetDataLength()){
									m_CallSt.m_pPrivateVarrent[j]=0;
								}
							}
							UniVar::DeleteBlock(m_CallSt.m_pPrivateVarrent);
						}
						m_pCallStack.Pop(m_CallSt);
					}
				}
				m_CallSt.iCurrent=pun.pbn->dwLabel;
				return LINE_JUMP;