userflow.h

一个多线程

#ifndef __userflow_h__
#define __userflow_h__
#include "style.h"
#define WORD_STYLE		0x100
#define WORD_STARTMAIN	0x101
#define	WORD_ENDMAIN	0x102
#define WORD_STARTPROC	0x103
#define WORD_ENDPROC	0x104
#define WORD_STARTEVENT	0x105
#define WORD_ENDEVENT	0x106
#define WORD_RESUME		0x107
#define WORD_SUSPEND	0x108
#define WORD_IF			0x109
#define WORD_THEN		0x10a
#define WORD_GOTO		0x10b
#define WORD_RET		0x10c
#define WORD_EXIT		0x10d
#define WORD_CALL		0x10e
#define WORD_SETVALUE	0x123
#define WORD_MTHEN		0x124
#define WORD_ELSE		0x125
#define WORD_ENDIF		0x126
#define WORD_WHILE		0x127
#define WORD_ENDWHILE	0x128
#define WORD_SWITCH		0x129
#define WORD_CASE		0x12a
#define	WORD_DEFAULT	0x12b
#define WORD_ENDSWITCH	0x12c
#define WORD_CONTINUE	0x12d
#define WORD_BREAK		0x12e
#define WORD_BVARIANT	0x12f
#define WORD_BNODE		0x130
#define WORD_DEFPROC	0x131
#define WORD_JUMP		0x132
#define WORD_BACK		0x133
#define WORD_RESET		0x134
#define WORD_BLOCK		0x135

struct EXPRESSION {
	int iStart;
	int iLength;
	DWORD dwPositionId;
};

struct LABELSTRUCT{
	DWORD dwLabelId;
	DWORD dwPositionId;
};

struct USERFUCTION{
	DWORD dwVarNum;
	int iStart;
	int iEnd;
	DWORD dwUserFuncPositionId;
	int ParamNum;
	int iStartParam;
};

struct USEREVENT{
	DWORD dwVarNum;
	int iStart;
	int iEnd;
	DWORD dwPositionId;
	EVENTTABLE * pstkEvent;
};

#define TYPE_PUBLIC_POS	0
#define TYPE_MAIN_POS	1
#define TYPE_FUNC_POS	2
#define TYPE_EVENT_POS	3

struct CPOSITION{
	short ihasLocalVariant;
	short istype;
	union PT{
		USERFUCTION * pf;
		USEREVENT * pe;
		void * pv;
	}pt;
	CString csTemp;
};

struct IF_ELSE_ENDIF{
	DWORD dwElseLbs,dwEndLbs;
};

struct WHILE_THEN{
	DWORD dwStartLbs,dwEndLbs;
};

struct CASE_INFO{
	DWORD dwExprId;
	DWORD dwEntryLbs;
};

struct SWITCH_CASE{
	DWORD dwExprTestLbs;
	DWORD dwEndLbs;
	CASE_INFO * pCaseInfo;
	int iNumOfCase;
};

struct ComStack{
	union {
		SWITCH_CASE * pSCase;
		WHILE_THEN * pWThen;
		IF_ELSE_ENDIF * pIThen;
	} cs;
	int iType;
};
#define IF_TYPE		0
#define WHILE_TYPE	1
#define SWITCH_TYPE	2

class AFX_EXT_CLASS CmplStack{
private:
	CArray <ComStack ,ComStack > m_StackList;
	int m_iPop;
	int m_iElse;
	int m_iEndif;
	int m_iBreak;
	int m_iContinue;
	int m_iEndWhile;
	int m_iEndSwitch;
public:
	BOOL pop(ComStack & cs){
		if(m_iPop<0||m_iPop>=m_StackList.GetSize())return FALSE;
		cs=m_StackList[m_iPop--];
		for(int i=m_iPop;i>=0;i--){
			if(m_StackList[i].iType==cs.iType){
				break;
			}
		}
		if(cs.iType==IF_TYPE){
			m_iElse=m_iEndif=i;
		}
		else if(cs.iType==SWITCH_TYPE){
			m_iEndSwitch=i;
			m_iBreak=max(m_iEndWhile,m_iEndSwitch);
		}
		else {
			m_iContinue=m_iEndWhile=i;
			m_iBreak=max(m_iEndWhile,m_iEndSwitch);
		}
		return TRUE;
	};

	WHILE_THEN * popwhile(BOOL & bLost){
		ComStack cs;
		bLost=FALSE;
		if(m_iEndWhile==-1)return NULL;
		if(m_iEndWhile==m_iPop){
			pop(cs);
			bLost=TRUE;
			return cs.cs.pWThen;
		}
		else {
			while(pop(cs)){
				if(cs.iType==WHILE_TYPE){
					return cs.cs.pWThen;
				}
				else {
					if(cs.iType==IF_TYPE){
						delete cs.cs.pIThen;
					}
					else if(cs.iType==SWITCH_TYPE){
						delete [] cs.cs.pSCase->pCaseInfo;
						delete cs.cs.pSCase;
					}
					else {
						delete cs.cs.pWThen;
					}
				}
			}
			return NULL;
		}
	};

	IF_ELSE_ENDIF * popif(BOOL & bLost){
		ComStack cs;
		bLost=FALSE;
		if(m_iEndif==-1)return NULL;
		if(m_iEndif==m_iPop){
			pop(cs);
			bLost=TRUE;
			return cs.cs.pIThen;
		}
		else {
			while(pop(cs)){
				if(cs.iType==IF_TYPE){
					return cs.cs.pIThen;
				}
				else {
					if(cs.iType==IF_TYPE){
						delete cs.cs.pIThen;
					}
					else if(cs.iType==SWITCH_TYPE){
						delete [] cs.cs.pSCase->pCaseInfo;
						delete cs.cs.pSCase;
					}
					else {
						delete cs.cs.pWThen;
					}
				}
			}
			return NULL;
		}
	};

	SWITCH_CASE * popswitch(BOOL & bLost){
		ComStack cs;
		bLost=FALSE;
		if(m_iEndSwitch==-1)return NULL;
		if(m_iEndSwitch==m_iPop){
			pop(cs);
			bLost=TRUE;
			return cs.cs.pSCase;
		}
		else {
			while(pop(cs)){
				if(cs.iType==SWITCH_TYPE){
					return cs.cs.pSCase;
				}
				else {
					if(cs.iType==IF_TYPE){
						delete cs.cs.pIThen;
					}
					else if(cs.iType==SWITCH_TYPE){
						delete [] cs.cs.pSCase->pCaseInfo;
						delete cs.cs.pSCase;
					}
					else {
						delete cs.cs.pWThen;
					}
				}
			}
			return NULL;
		}
	};

	void pushwhile(WHILE_THEN * pWThen)
	{
		ComStack cs;
		cs.cs.pWThen=pWThen;
		cs.iType=WHILE_TYPE;
		push(cs);
	};

	void pushswitch(SWITCH_CASE * pSCase)
	{
		ComStack cs;
		cs.cs.pSCase=pSCase;
		cs.iType=SWITCH_TYPE;
		push(cs);
	};

	void pushif(IF_ELSE_ENDIF * pIThen)
	{
		ComStack cs;
		cs.cs.pIThen=pIThen;
		cs.iType=IF_TYPE;
		push(cs);
	};

	void push(ComStack cs){
		if(m_iPop<0)m_iPop=-1;
		m_iPop++;
		if(m_iPop>=m_StackList.GetSize())
		{
			m_StackList.Add(cs);
			m_iPop=m_StackList.GetSize()-1;
		}
		else {
			m_StackList[m_iPop]=cs;
		}
		if(cs.iType==IF_TYPE){
			m_iElse=m_iEndif=m_iPop;
		}
		else if(cs.iType==SWITCH_TYPE){
			m_iBreak=m_iEndSwitch=m_iPop;
		}
		else {
			m_iBreak=m_iContinue=m_iEndWhile=m_iPop;
		}
	};

	DWORD GetBreak(){
		if(m_iBreak==-1)return 0xffffffff;
		ASSERT(m_iBreak<m_StackList.GetSize());
		if(m_StackList[m_iBreak].iType==SWITCH_TYPE){
			return m_StackList[m_iBreak].cs.pSCase->dwEndLbs;
		}
		else {
			return m_StackList[m_iBreak].cs.pWThen->dwEndLbs;
		}
	}

	DWORD GetContinue(){
		if(m_iContinue==-1)return 0xffffffff;
		ASSERT(m_iContinue<m_StackList.GetSize());
		return m_StackList[m_iContinue].cs.pWThen->dwStartLbs;
	}

	DWORD GetElse(){
		if(m_iElse==-1)return 0xffffffff;
		ASSERT(m_iElse<m_StackList.GetSize());
		return m_StackList[m_iElse].cs.pIThen->dwElseLbs;
	}

	DWORD GetEndif(){
		if(m_iEndif==-1)return 0xffffffff;
		ASSERT(m_iEndif<m_StackList.GetSize());
		return m_StackList[m_iEndif].cs.pIThen->dwEndLbs;
	}

	SWITCH_CASE * GetSwitch(){
		if(m_iEndSwitch==-1)return NULL;//0xffffffff;
		ASSERT(m_iEndSwitch<m_StackList.GetSize());
		return m_StackList[m_iEndSwitch].cs.pSCase;//->dwEndLbs;
	}

	DWORD GetEndSwitch(){
		if(m_iEndSwitch==-1)return 0xffffffff;
		ASSERT(m_iEndSwitch<m_StackList.GetSize());
		return m_StackList[m_iEndSwitch].cs.pSCase->dwEndLbs;
	}

	DWORD GetEndWhile(){
		if(m_iEndWhile==-1)return 0xffffffff;
		ASSERT(m_iEndWhile<m_StackList.GetSize());
		return m_StackList[m_iEndWhile].cs.pWThen->dwEndLbs;
	}

	CmplStack(){
		m_StackList.SetSize(10);
		m_iPop=-1;
		m_iElse=-1;
		m_iEndif=-1;
		m_iBreak=-1;
		m_iContinue=-1;
		m_iEndWhile=-1;
		m_iEndSwitch=-1;
	};

	BOOL ClearScope(){
		for(int i=0;i<=m_iPop&&i<m_StackList.GetSize();i++){
			if(m_StackList[i].iType==IF_TYPE){
				delete m_StackList[i].cs.pIThen;
			}
			else if(m_StackList[i].iType==SWITCH_TYPE){
				delete [] m_StackList[i].cs.pSCase->pCaseInfo;
				delete m_StackList[i].cs.pSCase;
			}
			else {
				delete m_StackList[i].cs.pWThen;
			}
		}
		if(m_iPop!=-1){
			m_iElse=-1;
			m_iEndif=-1;
			m_iBreak=-1;
			m_iContinue=-1;
			m_iEndWhile=-1;
			m_iEndSwitch=-1;
			m_iPop=-1;
			return true;
		}
		else return false;
	};

	~CmplStack(){
		ClearScope();
	};
};

struct B_VAR{
	LPSTR szKeyName;
	DWORD dwPosition;
};

struct B_NODE{
	LPSTR szDiscripe;
	DWORD dwLabel;
	DWORD dwInTimes;
	DWORD dwOutTimes;
	DWORD dwPosition;
};

class AFX_EXT_CLASS CUserFlow
{
private:
	CPOSITION m_mypos;
	WORDTABLE * m_pstkFlowWord;
	CArray <UniVar,UniVar&> m_ListConst;
	CArray <USERFUCTION,USERFUCTION&> m_ListFunction;
	CArray <USEREVENT,USEREVENT&> m_ListEvent;
	CArray <LABELSTRUCT,LABELSTRUCT&> m_LabelList;
	CArray <DWORD,DWORD&> m_CodeList;
	CArray <DWORD,DWORD> m_LineList;
	CArray <B_NODE,B_NODE&> m_ListBN;
	CScanner * m_pScanner;
	CArray <DWORD,DWORD&> m_LineCode;
	BOOL SetConstId(DWORD & dwType,LPSTR lpstr,DWORD & dwId,int iType=-1);
	BOOL ExpressionRead(LPSTR & lpstr,DWORD &dwType,DWORD & dwId,DWORD & dwExprId);
	int m_iuser;
	int m_icLine;
	int m_ierror;
	int m_iCurrentExpr;
public:
	CArray <CString * ,CString * >m_ListName;
	LPCTSTR GetFileName(DWORD id){
		if(id==0)return m_csFileName;
		id>>=16;
		id-=1;
		if(id>=0&&id<(DWORD)m_ListName.GetSize()){
			return *m_ListName[id];
		}
		return NULL;
	}
	DWORD m_dwFlowId;
	DWORD GetFileId(char * pName){
		if(m_csFileName==pName)
			return 0;
		for(int i=0;i<m_ListName.GetSize();i++){
			if(*m_ListName[i]==pName){
				return ((i+1)<<16);
			}
		}
		CString * ps=new CString(pName);
		m_ListName.Add(ps);
		return ((i+1)<<16);
	};
	B_NODE * GetBusinessNode(LPSTR lpName);
	CMapStringToPtr m_ConstStrTable,m_FlowStrTable;
	CArray <B_VAR,B_VAR&> m_ListBV;
	DWORD GetBusinessVarPosition(LPSTR lpstr){
		for(int i=0;i<m_ListBV.GetSize();i++){
			if(!strcmp(lpstr,m_ListBV[i].szKeyName))return m_ListBV[i].dwPosition;
		}
		return 0xffffffff;
	};

	DWORD NewLabel(DWORD dwL=0xffffffff,DWORD dwI=0xffffffff){
		LABELSTRUCT lbs;
		lbs.dwPositionId=dwI;
		lbs.dwLabelId=dwL;
		m_LabelList.Add(lbs);
		return ((m_LabelList.GetSize()-1)&POSID_FILTER)|TYPE_LABEL;
	};

	LABELSTRUCT * GetLabel(DWORD dwPositionId)
	{
		ASSERT((dwPositionId&POSID_FILTER)<(DWORD)m_LabelList.GetSize());
		return &m_LabelList[dwPositionId&POSID_FILTER];
	};
	void SetLabelLine(DWORD dwPositionId,DWORD dwL)
	{
		LABELSTRUCT * pl=GetLabel(dwPositionId);
		if(pl)pl->dwLabelId=dwL;
	}
	CmplStack m_Cmpl;
	CArray <PARAMEMTER,PARAMEMTER&> m_ParamArray;
	CStyle * m_pStyle;
	CArray <EXPRESSION,EXPRESSION&> m_ExprList;
	CArray <DWORD,DWORD&> m_ExprWordList;
	USERFUCTION m_MainFunc;
	DWORD dwGlobalVarNum;
	void AddRef(){m_iuser++;};
	void Release(){m_iuser--;/*if(!m_iuser)delete this;*/};

	CFunctionRegister * m_pRegister;
	int m_iMainStart,iMainEnd;
	CString m_csFileName;
	void * GetStructFromId(DWORD dwID);
	void WriteError(LPCTSTR pName,int line,char * samp,char * error){
		::WriteError((LPSTR)pName,line,samp,error);
	};

	CUserFlow(CFunctionRegister * pRegister,LPSTR lpFlowFile);
	virtual ~CUserFlow();
	BOOL GetConst(DWORD dwConstID,UniVar & tv);

	BOOL ReadLine(BOOL bAddLine=TRUE,LPSTR pString=NULL,DWORD dwId=0);
	BOOL GetCode();

	DWORD * GetLine(int iLine);
	BOOL GetPositionId(LPCTSTR lpstr,DWORD & dwPos,DWORD dwType=WORD_IDENTY,BOOL b=FALSE);
	DWORD GetIdFromPosition(DWORD dwID);

	static CMapStringToPtr m_StrFlowCommand;
	static CUserFlow * GetFlow(CFunctionRegister * pRegister,LPSTR lpFlowFile,DWORD dwId);
	static void CloseFlow(CUserFlow * p);
	USEREVENT * GetEvent(DWORD dwId);
};

class AFX_EXT_CLASS CFlowMg{
	CArray<CUserFlow *,CUserFlow *> m_FlowList;
	HANDLE m_hMutex;
public :
	CUserFlow * GetFlow(CFunctionRegister * pRegister,LPSTR lpFlowFile,DWORD dwId=0);
	CUserFlow * FindFlow(CFunctionRegister * pRegister,LPSTR lpFlowFile)
	{
		for(int i=0;i<m_FlowList.GetSize();i++){
			if(!m_FlowList[i]->m_csFileName.CompareNoCase(lpFlowFile))
				return m_FlowList[i];
		}
		return NULL;
	};
	CUserFlow * FindFlow(DWORD dwId,BOOL bSet=FALSE)
	{
		if(bSet)WaitForSingleObject(m_hMutex,INFINITE);
		for(int i=0;i<m_FlowList.GetSize();i++){
			if(m_FlowList[i]->m_dwFlowId==dwId){
				if(bSet)ReleaseMutex(m_hMutex);
				return m_FlowList[i];
			}
		}
		if(bSet)ReleaseMutex(m_hMutex);
		return NULL;
	};
	void CloseAll(){
		for(int i=0;i<m_FlowList.GetSize();i++){
			CString cs=m_FlowList[i]->m_csFileName;
			try{
				delete m_FlowList[i];
			}
			catch(...){
				TRACE("flow delete error:%s",(LPCTSTR)cs);
			}
		}
		m_FlowList.RemoveAll();
	};
	CFlowMg();
	~CFlowMg()
	{
		CUserFlow::m_StrFlowCommand.RemoveAll();
		CloseHandle(m_hMutex);
		CloseAll();
	};
	void CloseFlow(CUserFlow * p)
	{
		for(int i=0;i<m_FlowList.GetSize();i++){
			if(m_FlowList[i]==p)m_FlowList.RemoveAt(i);
		};
		delete p;
	};
};

extern CFlowMg gFlowMg;

#endif