userctrl.cpp

一个多线程

				}
			}
			pdwCrerentLine=m_pUserFlow->GetLine(m_CallSt.iCurrent);
			if(TestBreak(pdwCrerentLine[0])){
				SetCurrentLine();
				m_bFunctionBreak=FALSE;
				return 1;
			}
		}
		m_bFunctionBreak=FALSE;
	}
	else {
		m_iRound=-1;
	}
	if(bProxy&&m_pUserControl){
		return m_pUserControl->AddTask();
	}
	else
		return RunTask();
}

int CFlowControl::RunResume(UniVar * pVar,int iNum)
{
	try{
		if(m_bStart!=1)return 0;
		if(m_Status!=FLOW_IDLE){
			return 0;
		}
		m_bStop=FALSE;
		for(int i=0;i<iNum;i++){
			RestoreCurrentParam(pVar[i],i);
		}
		if(m_bFunctionBreak){
			for(int ii=0;ii<m_CallSt.cNumOfParam;ii++){
				m_ParamList[ii+m_CallSt.iParamStart]=0;
			}
			m_CallSt.iCurrent++;
			if(m_bDebug){
				if(m_iRound>0)m_iRound--;
				if(pdwCrerentLine){
					if(m_iRound<=1&&m_iRound>=0){
						m_iRound=0;
						pdwCrerentLine=m_pUserFlow->GetLine(m_CallSt.iCurrent);
						SetCurrentLine();
						m_bFunctionBreak=FALSE;
						return 1;
					}
				}
				pdwCrerentLine=m_pUserFlow->GetLine(m_CallSt.iCurrent);
				if(TestBreak(pdwCrerentLine[0])){
					SetCurrentLine();
					m_bFunctionBreak=FALSE;
					return 1;
				}
			}
			m_bFunctionBreak=FALSE;
		}
		else {
			m_iRound=-1;
		}
	}
	catch(...){
		return 0;
	}
	return RunTask();
}

int CFlowControl::Suspend()
{
	m_bStop=TRUE;
	m_pUserControl->EndTask(10000);
	return 0;
}

int CFlowControl::Step(int istep,BOOL bProxy)
{
	if(m_Status!=FLOW_IDLE)return 0;
	if(m_bStart!=1){
		m_bFunctionBreak=FALSE;
		m_bStart=1;
		if(m_pUserControl){
			m_pUserControl->OnPreStartFlow();
		}
		else{
			return 0;
		}
		m_CallSt.pt.pFun=&m_pUserFlow->m_MainFunc;
		m_CallSt.iType=CALL_MAIN;
		m_CallSt.iCurrent=m_CallSt.pt.pFun->iStart;
		if(m_CallSt.pt.pFun->dwVarNum){
			m_CallSt.m_pPrivateVarrent=(UniVar *)UniVar::NewBlock(sizeof(UniVar)*m_CallSt.pt.pFun->dwVarNum);
			memset(m_CallSt.m_pPrivateVarrent,0,sizeof(UniVar)*m_CallSt.pt.pFun->dwVarNum);
		}
		else {
			m_CallSt.m_pPrivateVarrent=NULL;
		}
		SetDebug(TRUE);
		StartDebug();
	}
	ASSERT(istep>0);
	m_bStop=FALSE;
	m_iRound=istep;

	if(bProxy&&m_pUserControl){
		return m_pUserControl->AddTask();
	}
	else
		return RunTask();
}

int CFlowControl::OnEvent(DWORD dwEvent,UniVar tv1,UniVar tv2,BOOL bProxy)
{
	if(m_bStart!=1)return 0;
	pun.pVoid=m_pUserFlow->GetEvent((dwEvent&POSID_FILTER)|TYPE_EVENT);
	if(!pun.pVoid)return 0;
	if(m_Status!=FLOW_IDLE){
		m_pUserControl->EndTask(2000);
	}
	m_bFunctionBreak=FALSE;
	if(m_bDebug)
		m_iRound=-1;
	m_pCallStack.Push(m_CallSt);
	m_CallSt.pt.pEv=pun.pevt;
	if(m_CallSt.pt.pEv->dwVarNum){
		m_CallSt.m_pPrivateVarrent=(UniVar *)UniVar::NewBlock(sizeof(UniVar)*m_CallSt.pt.pEv->dwVarNum);
		memset(m_CallSt.m_pPrivateVarrent,0,sizeof(UniVar)*m_CallSt.pt.pEv->dwVarNum);
		m_CallSt.m_pPrivateVarrent[0]=tv1;
		m_CallSt.m_pPrivateVarrent[1]=tv2;
	}
	m_CallSt.iType=CALL_EVENT;
	m_CallSt.iCurrent=pun.pevt->iStart;
	if(bProxy&&m_pUserControl){
		return m_pUserControl->AddTask();
	}
	else
		return RunTask();
}

int CFlowControl::RunTask()
{
	m_Status=FLOW_TASK_RUN;
	COMMANDRESULT mst;
	pdwCrerentLine=m_pUserFlow->GetLine(m_CallSt.iCurrent);
	if(!pdwCrerentLine){
		m_Status=FLOW_IDLE;
		EndFlow();
		return 0;
	}

	while(TRUE){
		try {
			mst=RunLine(pdwCrerentLine+1);
		}
		catch(...){
			if(!m_pUserControl->ControlValid()){
				m_Status=FLOW_IDLE;
				return 0;
			}
			if(pdwCrerentLine)
				if(gDllGlobalManager.m_pGlobalApi)
					gDllGlobalManager.m_pGlobalApi->GLogEvent(exceptionLog,pdwCrerentLine[0],0,(LPSTR)(LPCTSTR)this->m_pUserFlow->m_csFileName ,"flexcept.txt");
			mst=LINE_CONTINUE;
		}
		if(mst==LINE_CONTINUE){
			m_CallSt.iCurrent++;
		}
		else if(mst==LINE_END)
		{
			if(!m_pUserControl->ControlValid()){
				m_Status=FLOW_IDLE;
				return 0;
			}
			m_Status=FLOW_IDLE;
			EndFlow();
			return 0;
		}
		else if(mst==LINE_PAUSE){
			m_bFunctionBreak=TRUE;
			break;
		}
		if(m_bDebug){
			if(m_iRound>0)m_iRound--;
		}
		pdwCrerentLine=m_pUserFlow->GetLine(m_CallSt.iCurrent);
		if(!pdwCrerentLine){
			m_Status=FLOW_IDLE;
			EndFlow();
			return 0;
		}
		if(m_bStop)break;
		if(m_bDebug){
			if(!m_iRound)break;
			if(TestBreak(pdwCrerentLine[0])){
				m_iRound=0;
				break;
			}
		}
	}
	if(m_bDebug){
		if(mst!=LINE_END&&mst!=LINE_PAUSE){
			SetCurrentLine();
		}
	}
	m_Status=FLOW_IDLE;
	return 0;
}

BOOL CFlowControl::TestBreak(int iLine)
{
	if(m_pUserControl)return m_pUserControl->IsBreakPoint(iLine);
	else return FALSE;
}

BOOL CUserControl::GetSysVarValue(DWORD dwVarID,UniVar & tv)
{
	return GetVarValue(dwVarID,tv);
}

int CFlowControl::Exit()
{
	m_bStop=TRUE;
	CUserControl * pc=m_pUserControl;
	m_pUserControl->EndTask(2000);
	if(pc!=m_pUserControl||!pc->IsValid()){
		return 0;
	}
	EndFlow();
	return 0;
}

BOOL CFlowControl::PushC(DWORD dwId)
{
	if((dwId&ITYPE_FILTER)==TYPE_SYSTEM){
		UniVar tv(dwId,DATA_TYPE_OPERATOR),tv1,tv2,tv3,vt;
		if(dwId==WORD_LEFTSMLBRACKET){
			RPush(tv);
		}
		else{
			while(1){
				if(!GetTop(tv1)){RPush(tv);return TRUE;}
				if((tv1.bIsOperator())&&((DWORD)tv1==WORD_LEFTSMLBRACKET)){RPush(tv);return TRUE;}
				if(!GetsTop(tv2)){
					if(dwId!=WORD_RIGHTSMLBRACKET)RPush(tv);
					return TRUE;
				}
				if((tv2.bIsOperator())&&((DWORD)tv2==WORD_LEFTSMLBRACKET)){
					if(dwId==WORD_RIGHTSMLBRACKET){
						RPop(tv1);
						RPop(tv2);
						RPush(tv1);
						return TRUE;
					}
					else{
						RPush(tv);
						return TRUE;
					}
				}
				if(bPrior(dwId,(DWORD)tv2)){
					ASSERT(dwId!=WORD_RIGHTSMLBRACKET);
					RPush(tv);
					return TRUE;
				};
				RPop(tv1);
				RPop(tv2);
				if(!RPop(tv3)){ASSERT(0);RPush(tv);return TRUE;}
				if((tv3.bIsOperator())&&((DWORD)tv3==WORD_LEFTSMLBRACKET)){ASSERT(0);RPush(tv);return TRUE;}
				tv1=iCalculate((DWORD)tv2,tv3,tv1);
				RPush(tv1);
			}
		}
	}
	else {
		UniVar tv,tv1,tv2;
		if(!GetDataValue(dwId,tv))return FALSE;
		if(!GetTop(tv1)){RPush(tv);return TRUE;}
		if(tv1.bIsOperator()){
			if((DWORD)tv1==WORD_NOT){
				RPop(tv1);
				tv=!tv;
				RPush(tv);
				return TRUE;
			}
			else if((DWORD)tv1==WORD_OPS){
				RPop(tv1);
				tv=~tv;
				RPush(tv);
				return TRUE;
			}
			else if((DWORD)tv1==WORD_SUB){
				if(!GetsTop(tv2)){
					RPop(tv1);
					tv=-tv;
					RPush(tv);
					return TRUE;
				}
				else {
					if(tv2.bIsOperator()){
						if((DWORD)tv2==WORD_LEFTSMLBRACKET){
							RPop(tv1);
							tv=-tv;
							RPush(tv);
							return TRUE;
						}
					}
				}
			}
		}
		RPush(tv);
	}
	return TRUE;
}

void CUserControl::WaitStop(){
	if(m_pControl){
		if(m_pControl->m_Status==FLOW_IDLE)return ;
			EndTask();
	}
}
void CUserControl::CloseFlow(BOOL bReal){
	CFlowControl * pc=m_pControl;
	ExitFlow();
	if(m_pControl==pc&&pc){
		delete m_pControl;
		m_pControl=NULL;
	}
	else{
		return;
	}
	if(bReal&&m_pFlow)
		CUserFlow::CloseFlow(m_pFlow);
	m_pFlow=NULL;
}

void CUserControl::EndDebug()
{
	if(gDllGlobalManager.m_pGlobalApi)
		gDllGlobalManager.m_pGlobalApi->APIEndDebug(this);
}

void CUserControl::SetLine(int iLine)
{
	if(gDllGlobalManager.m_pGlobalApi)
		gDllGlobalManager.m_pGlobalApi->APISetLine(this,iLine);
}

BOOL CUserControl::IsBreakPoint(int iLine)
{
	if(gDllGlobalManager.m_pGlobalApi)
		return gDllGlobalManager.m_pGlobalApi->APIIsBreakPoint(this,iLine);
	else return FALSE;
}

void CUserControl::StartDebug()
{
	if(gDllGlobalManager.m_pGlobalApi)
		gDllGlobalManager.m_pGlobalApi->APIStartDebug(this);
}

void CUserControl::SafeRun(UniVar * pVar,int iNum)
{
	GetRoadRight();
	try{
		m_pControl->RunResume(pVar,iNum);
	}
	catch(...){
	}
	ReleaseRoadRight();
}

BOOL CUserControl::AddTask()
{
	if(!m_pControl||m_pControl->m_Status!=FLOW_IDLE)return FALSE;
	CUniMsg um;
	um.m_dwCommand=EVENT_RUN_TASK;
	um.m_pReceivor=um.m_pSender=this;
	um.m_btMsgType=MSG_SYNCMD;
	um.m_ierror=1;
	m_pControl->m_Status=FLOW_TASK_QUEUE;
	if(m_pBus->SendMessage(&um)){
		return TRUE;
	}
	else{
		m_pControl->m_Status=FLOW_IDLE;
		return FALSE;
	}
}

void CUserControl::EndTask(DWORD dwTimeOut)
{
	if(!m_pControl||m_pControl->m_Status==FLOW_IDLE)return ;
	WaitForSingleObject(m_pBus->m_pRoad[m_btPointRoad]->m_pData->m_hMutex,dwTimeOut);
	if(m_btCurRoad){
		if(m_pBus->m_pRoad[m_btPointRoad]->m_pCurMsg->m_pReceivor==this&&
			m_pBus->m_pRoad[m_btPointRoad]->m_pCurMsg->m_dwCommand==EVENT_RUN_TASK){
			//on run
			HANDLE hNutex=m_pBus->m_pRoad[m_btCurRoad]->m_hFlowMutex;
			ReleaseMutex(m_pBus->m_pRoad[m_btPointRoad]->m_pData->m_hMutex);
			DWORD i=0;
			while(m_btCurRoad&&m_pControl->m_Status!=FLOW_IDLE){
				i+=30;
				Sleep(30);
				if(i>=dwTimeOut)
					return;
			}
			m_pControl->m_Status=FLOW_IDLE;
			return;
		}
		else{
			for(int i=0;i<m_pBus->m_pRoad[m_btPointRoad]->m_pOwnMsg->GetSize();i++){
				CUniMsg * pMsg=m_pBus->m_pRoad[m_btPointRoad]->m_pOwnMsg->GetAt(i);
				if(pMsg->m_pReceivor==this&&pMsg->m_dwCommand==EVENT_RUN_TASK){
					m_pBus->m_pRoad[m_btPointRoad]->m_pOwnMsg->RemoveAt(i);
					ReleaseMutex(m_pBus->m_pRoad[m_btPointRoad]->m_pData->m_hMutex);
					delete pMsg;
					m_pControl->m_Status=FLOW_IDLE;
					return;
				}
			}
		}
	}
	POSITION pos=m_pBus->m_pRoad[m_btPointRoad]->m_pData->m_ListMsg.GetHeadPosition(),pos1;
	while(pos){
		pos1=pos;
		CUniMsg * pMsg=m_pBus->m_pRoad[m_btPointRoad]->m_pData->m_ListMsg.GetNext(pos);
		if(pMsg->m_pReceivor==this&&pMsg->m_dwCommand==EVENT_RUN_TASK){
			m_pBus->m_pRoad[m_btPointRoad]->m_pData->m_ListMsg.RemoveAt(pos1);
			ReleaseMutex(m_pBus->m_pRoad[m_btPointRoad]->m_pData->m_hMutex);
			delete pMsg;
			m_pControl->m_Status=FLOW_IDLE;
			return;
		}
	}
	ReleaseMutex(m_pBus->m_pRoad[m_btPointRoad]->m_pData->m_hMutex);
}

int CUserControl::Start(BOOL bProxy)
{
	if(m_pControl){
		if(gDllGlobalManager.m_pGlobalApi)
			gDllGlobalManager.m_pGlobalApi->APIOnStart(this);
		return m_pControl->Start(bProxy);
	}
	return 0;
};