userctrl.cpp

一个多线程

			}
		case WORD_GOTO:
			pun.pVoid=m_pUserFlow->GetStructFromId(pLine[1]);
			if(!pun.pVoid)return LINE_CONTINUE;
			if(m_CallSt.iType!=CALL_EVENT){
				if(pun.plbe->dwLabelId<(DWORD)m_CallSt.pt.pFun->iStart||pun.plbe->dwLabelId>(DWORD)m_CallSt.pt.pFun->iEnd)
					return LINE_CONTINUE;
			}
			else {
				if(pun.plbe->dwLabelId<(DWORD)m_CallSt.pt.pEv->iStart||pun.plbe->dwLabelId>(DWORD)m_CallSt.pt.pEv->iEnd)return LINE_CONTINUE;
			}
			m_CallSt.iCurrent=pun.plbe->dwLabelId;
			return LINE_JUMP;
		case WORD_STARTPROC:
			break;
		case WORD_STARTEVENT:
			break;
		case WORD_STARTMAIN:
			break;
		case WORD_ENDPROC:
			if(m_CallSt.m_pPrivateVarrent){
				FUNCALLSTATUS fcst=m_CallSt;
				if(!m_pCallStack.Pop(m_CallSt)){
					return LINE_END;
				};
				for(int ii=0;ii<fcst.pt.pFun->ParamNum;ii++){
					if(m_pUserFlow->m_ParamArray[fcst.pt.pFun->iStartParam+ii].tv.inout==USE_TYPE_INOUT){
						SetDataValue(m_CallSt.pdwCrerentLine[ii],fcst.m_pPrivateVarrent[ii]);
					}
				}
				{
					for(int j=0;j<(int)fcst.pt.pFun->dwVarNum;j++){
						if(fcst.m_pPrivateVarrent[j].GetDataLength()){
							fcst.m_pPrivateVarrent[j]=0;
						}
					}
					UniVar::DeleteBlock(fcst.m_pPrivateVarrent);
				}
				m_CallSt.iCurrent++;
				return LINE_JUMP;
			}
			else {
				if(m_pCallStack.Pop(m_CallSt)){
					m_CallSt.iCurrent++;
					return LINE_JUMP;
				};
			}
			return LINE_END;
		case WORD_ENDEVENT:
			{
				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);
				pdwCrerentLine=m_pUserFlow->GetLine(m_CallSt.iCurrent);
				EventCallOver(0,dwId,up1,up2);
			}
			return LINE_PAUSE;
		case WORD_ENDMAIN:
			return LINE_END;
		case WORD_RESUME:
			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);
					return LINE_CONTINUE;
				}
				else if(m_CallSt.iType==CALL_MAIN)return LINE_CONTINUE;
				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);
			}
		case WORD_RET:
			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);
				pdwCrerentLine=m_pUserFlow->GetLine(m_CallSt.iCurrent);
				EventCallOver(0,dwId,up1,up2);
				return LINE_PAUSE;
			}
			else if(m_CallSt.iType==CALL_FUNC){
				if(m_CallSt.m_pPrivateVarrent){
					FUNCALLSTATUS fcst=m_CallSt;
					if(!m_pCallStack.Pop(m_CallSt)){
						return LINE_END;
					};
					for(int ii=0;ii<fcst.pt.pFun->ParamNum;ii++){
						if(m_pUserFlow->m_ParamArray[fcst.pt.pFun->iStartParam+ii].tv.inout==USE_TYPE_INOUT){
							SetDataValue(m_CallSt.pdwCrerentLine[ii],fcst.m_pPrivateVarrent[ii]);
						}
					}
					{
						for(int j=0;j<(int)fcst.pt.pFun->dwVarNum;j++){
							if(fcst.m_pPrivateVarrent[j].GetDataLength()){
								fcst.m_pPrivateVarrent[j]=0;
							}
						}
						UniVar::DeleteBlock(fcst.m_pPrivateVarrent);
					}
					m_CallSt.iCurrent++;
					return LINE_JUMP;
				}
				else {
					if(m_pCallStack.Pop(m_CallSt)){
						m_CallSt.iCurrent++;
						return LINE_JUMP;
					};
				}
			}
			return LINE_END;
		case WORD_EXIT:
			return LINE_END;
		case WORD_SUSPEND:
			return LINE_PAUSE;
		case WORD_IF:
			{
				if(pLine[2]==WORD_THEN){
					if(Compare(pLine[1]))
						return RunLine(pLine+3);
				}
				else {
					if(!Compare(pLine[1])){
						pun.pVoid=m_pUserFlow->GetStructFromId(pLine[3]);
						if(!pun.pVoid)
							return LINE_END;
						m_CallSt.iCurrent=pun.plbe->dwLabelId;
						return LINE_JUMP;
					}
				}
			}
			break;
		case WORD_WHILE:
			{
				if(!Compare(pLine[1])){
					pun.pVoid=m_pUserFlow->GetStructFromId(pLine[3]);
					if(!pun.pVoid)
						return LINE_END;
					m_CallSt.iCurrent=pun.plbe->dwLabelId;
					return LINE_JUMP;
				}
			}
			break;
		case WORD_SWITCH:
			{
				UniVar tv,tv1;
				tv=Calculate(pLine[1]);
				pun.pVoid=m_pUserFlow->GetStructFromId(pLine[3]);
				if(!pun.pVoid)
					return LINE_END;
				pun.pVoid=m_pUserFlow->GetStructFromId(pun.plbe->dwLabelId);
				if(!pun.pVoid)return 
					LINE_END;
				DWORD dwEndLbs=pun.plbe->dwLabelId;
				int iNum=pun.plbe->dwPositionId;
				for(int i=0;i<iNum;i++){
					if(pun.plbe[1+i].dwLabelId==WORD_DEFAULT){
						pun.pVoid=m_pUserFlow->GetStructFromId(pun.plbe[1+i].dwPositionId);
						m_CallSt.iCurrent=pun.plbe->dwLabelId;
						return LINE_JUMP;
					}
					else {
						tv1=Calculate(pun.plbe[1+i].dwLabelId);
						if((BOOL)(tv==tv1)){
							pun.pVoid=m_pUserFlow->GetStructFromId(pun.plbe[1+i].dwPositionId);
							m_CallSt.iCurrent=pun.plbe->dwLabelId;
							return LINE_JUMP;
						}
					}
				}
				pun.pVoid=m_pUserFlow->GetStructFromId(dwEndLbs);
				m_CallSt.iCurrent=pun.plbe->dwLabelId;
				return LINE_JUMP;
			}
			break;
		case WORD_BLOCK:
			{
				UniVar tv=Calculate(pLine[2]);
				int i=(int)tv;
				if(i<0)i=0;
				tv.SetValue((void *)NULL,i);
				SetDataValue(pLine[1],tv);
				return LINE_CONTINUE;
			}
		case WORD_SETVALUE:
			{
				UniVar tv=Calculate(pLine[2]);
				SetDataValue(pLine[1],tv);
				return LINE_CONTINUE;
			}
		default:
			break;
		}
		break;
	default:
		break;
	}
	return LINE_CONTINUE;
}

UniVar CFlowControl::Calculate(DWORD dwExprId)
{
	UniVar tv=(0);
	if((dwExprId&ITYPE_FILTER)==TYPE_EXPR){
		if((dwExprId&POSID_FILTER)<(DWORD)m_pUserFlow->m_ExprList.GetSize()){
			EXPRESSION & epr=m_pUserFlow->m_ExprList[dwExprId&POSID_FILTER];
			MYASSERT(iPop==-1);
			int ist=epr.iStart;
			DWORD dwWord=m_pUserFlow->m_ExprWordList[ist];
			while(ist<epr.iStart+epr.iLength){
				PushC(dwWord);
				ist++;
				if(ist>=epr.iStart+epr.iLength)break;
				dwWord=m_pUserFlow->m_ExprWordList[ist];
			}
			PushC(WORD_RIGHTSMLBRACKET);
			BOOL bret=RPop(tv);
			MYASSERT(iPop==-1);
			MYASSERT(bret);
		}
	}
	else {
		GetDataValue(dwExprId,tv);
	}
	return tv;
}

BOOL CFlowControl::GetCodeValue(DWORD dwExprId,UniVar & tv)
{
	if((dwExprId&ITYPE_FILTER)==TYPE_EXPR){
		if((dwExprId&POSID_FILTER)<(DWORD)m_pUserFlow->m_ExprList.GetSize()){
			EXPRESSION & epr=m_pUserFlow->m_ExprList[dwExprId&POSID_FILTER];
			int ist=epr.iStart;
			MYASSERT(iPop==-1);
			DWORD dwWord=m_pUserFlow->m_ExprWordList[ist];
			while(ist<epr.iStart+epr.iLength){
				PushC(dwWord);
				ist++;
				dwWord=m_pUserFlow->m_ExprWordList[ist];
			}
			PushC(WORD_RIGHTSMLBRACKET);
			MYASSERT(iPop==-1);
			return RPop(tv);
		}
		else {
			return FALSE;
		}
	}
	else {
		return GetDataValue(dwExprId,tv);
	}
}

BOOL CFlowControl::Compare(DWORD dwExprId)
{
	UniVar tv=Calculate(dwExprId);
	return tv.IsTrue();
}

UniVar * CFlowControl::GetCurrentParem()
{
	return &m_ParamList[m_CallSt.iParamStart];
}

BOOL CFlowControl::RestoreCurrentParam(UniVar & uv,int iNum)
{
	if(!m_CallSt.pun.pcmd||!pdwCrerentLine)return FALSE;
	if(iNum<m_CallSt.pun.pcmd->ParamNum){
		UniVar * pv=&m_pUserFlow->m_pStyle->m_ParamArray[m_CallSt.pun.pcmd->iStartParam+iNum].tv;
		if(pv->inout==USE_TYPE_INOUT){
			SetDataValue(pdwCrerentLine[iNum+2],uv);
		}
		return TRUE;
	}
	else if(iNum<m_CallSt.cNumOfParam){
		return SetDataValue(pdwCrerentLine[iNum+2],uv);
	}
	return FALSE;
}

int CFlowControl::Start(BOOL bProxy)
{
	if(!m_pUserFlow)return 0;
	if(m_Status!=FLOW_IDLE){
		m_pUserControl->EndTask(100);
	}
	if(m_bStart!=1){
		m_bFunctionBreak=FALSE;
		m_bStart=1;
		m_pUserControl->OnPreStartFlow();
		m_bStop=FALSE;
		if(m_bDebug){
			m_iRound=-1;
			StartDebug();
		}
		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;
		}
		if(bProxy&&m_pUserControl){
			return m_pUserControl->AddTask();
		}
		else
			return RunTask();
	}
	else {
		return 0;
	}
}

void CFlowControl::EndFlow(){
	try {
		if(m_bStart==1){
			CUserControl * pc=m_pUserControl;
			if(m_pUserControl)m_pUserControl->OnEndFlow();
			if(pc!=m_pUserControl||!pc->IsValid()||!pc->ControlValid()){
				return;
			}
			if(m_bDebug)
				EndDebug();
			m_bStart=2;
			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_pUserControl=NULL;
			memset(&m_CallSt,0,sizeof(m_CallSt));
		}
	}
	catch(...){
	}
};

void CFlowControl::EventCallOver(int exitCode,DWORD dwEventId,UniVar & p1,UniVar & p2)
{
	if(m_pUserControl)
		m_pUserControl->EventCallOver(exitCode,dwEventId&POSID_FILTER,p1,p2);
}

void CFlowControl::StartDebug(){
	if(m_pUserControl)
		m_pUserControl->StartDebug();
};

void CFlowControl::EndDebug(){
	if(m_pUserControl)
		m_pUserControl->EndDebug();
};

void CFlowControl::SetLine(int iLine){
	if(m_pUserControl)
		m_pUserControl->SetLine(iLine);
};

int CUserControl::FunctionReturn(UniVar uvi,...)
{
	if(!m_pControl)return 0;
	if(!UniVar::ValidVar(&uvi)){
		return m_pControl->Resume();
	}
	m_pControl->RestoreCurrentParam(uvi,0);
	va_list varl;
	va_start(varl,uvi);
	UniVar uv;
	int i=1;
	while(1){
		uv=va_arg(varl,UniVar);
		if(UniVar::ValidVar(&uv)){
			m_pControl->RestoreCurrentParam(uv,i);
			i++;
		}
		else break;
	};
	va_end(varl);
	if(m_pControl->Resume())return i;
	return 0;
}

int CFlowControl::Resume(BOOL bProxy)
{
	if(m_bStart!=1)return 0;
	if(m_Status!=FLOW_IDLE){
		m_pUserControl->EndTask(100);
	}
	m_bStop=FALSE;
	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;