univar.cpp

一个多线程

{
	return Calculate(tv1,tv2,14);
}

UniVar operator <(const UniVar & tv1,const UniVar & tv2)
{
	return Calculate(tv1,tv2,15);
}

UniVar iCalculate(DWORD dwOp,const UniVar & tv3,const UniVar & tv4)
{
	int iFlag=0;
	switch(dwOp){
	case WORD_ADD	: iFlag=0;break;
	case WORD_SUB	: iFlag=1;break;
	case WORD_MUL	: iFlag=2;break;
	case WORD_DEV	: iFlag=3;break;
	case WORD_BIG	: iFlag=10;break;
	case WORD_SML	: iFlag=15;break;
	case WORD_SAM	: iFlag=12;break;
	case WORD_BGE	: iFlag=11;break;
	case WORD_SME	: iFlag=14;break;
	case WORD_AND	: iFlag=8;break;
	case WORD_OR	: iFlag=9;break;
	case WORD_BAND	: iFlag=6;break;
	case WORD_BOR	: iFlag=7;break;
	case WORD_XOR	: iFlag=5;break;
	case WORD_MOD	: iFlag=4;break;
	case WORD_NEQ	: iFlag=13;break;
	default:return UniVar(0);
	}
	return Calculate(tv3,tv4,iFlag);
}

BOOL bPrior(DWORD d1,DWORD d2)
{
	int iFlag=0,iFlag1;
	switch(d1){
	case WORD_ADD	: iFlag=3;break;
	case WORD_SUB	: iFlag=3;break;
	case WORD_MUL	: iFlag=5;break;
	case WORD_DEV	: iFlag=5;break;
	case WORD_BIG	: iFlag=2;break;
	case WORD_SML	: iFlag=2;break;
	case WORD_SAM	: iFlag=2;break;
	case WORD_BGE	: iFlag=2;break;
	case WORD_SME	: iFlag=2;break;
	case WORD_AND	: iFlag=1;break;
	case WORD_OR	: iFlag=1;break;
	case WORD_BAND	: iFlag=4;break;
	case WORD_BOR	: iFlag=4;break;
	case WORD_XOR	: iFlag=4;break;
	case WORD_MOD	: iFlag=5;break;
	case WORD_NEQ	: iFlag=2;break;
	case WORD_LEFTSMLBRACKET: iFlag=6;break;
	case WORD_RIGHTSMLBRACKET: iFlag=0;break;
	default: ASSERT(0);return FALSE;
	}
	iFlag1=iFlag;
	switch(d2){
	case WORD_ADD	: iFlag=3;break;
	case WORD_SUB	: iFlag=3;break;
	case WORD_MUL	: iFlag=5;break;
	case WORD_DEV	: iFlag=5;break;
	case WORD_BIG	: iFlag=2;break;
	case WORD_SML	: iFlag=2;break;
	case WORD_SAM	: iFlag=2;break;
	case WORD_BGE	: iFlag=2;break;
	case WORD_SME	: iFlag=2;break;
	case WORD_AND	: iFlag=1;break;
	case WORD_OR	: iFlag=1;break;
	case WORD_BAND	: iFlag=4;break;
	case WORD_BOR	: iFlag=4;break;
	case WORD_XOR	: iFlag=4;break;
	case WORD_MOD	: iFlag=5;break;
	case WORD_NEQ	: iFlag=2;break;
	case WORD_LEFTSMLBRACKET: iFlag=6;break;
	case WORD_RIGHTSMLBRACKET: iFlag=0;break;
	default: ASSERT(0);return FALSE;
	}
	return (iFlag1>iFlag);
}

bool UniVar::Getbyte(int idx,UniVar & tv)
{
	switch(it){
	case DATA_TYPE_HANDLE	:
	case DATA_TYPE_STRING	:
		if(idx>0&&idx<GetDataLength()){
			tv=(int)uv.bv[idx];
			return true;
		}
		break;
	case DATA_TYPE_INT		:
	case DATA_TYPE_DWORD	:
		if(idx>=0||idx<4){
			char * p1=(char *)&uv.iv;
			tv=(int)(p1[idx]);
			return true;
		}
		break;
	case DATA_TYPE_FLOAT	:
		if(idx>=0||idx<8){
			char * p1=(char *)&uv.iv;
			tv=(int)(p1[idx]);
			return true;
		}
		break;
	default:
		break;
	}
	tv=0;
	return false;
}

void UniVar::BlockSet(BLOCKOPRATOR iFlag,UniVar & tv,int iFirst,int iLen,int iReset)
{
	switch(iReset){
	case DATA_TYPE_HANDLE	:
		tv.SetValue((void *)NULL,0);
		break;
	case DATA_TYPE_STRING	:
		tv="";
		break;
	case DATA_TYPE_INT		:
		if(iLen==0)iLen=4;
		tv=0;
		break;
	case DATA_TYPE_DWORD	:
		if(iLen==0)iLen=4;
		tv=(DWORD)0;
		break;
	case DATA_TYPE_FLOAT	:
		if(iLen==0)iLen=8;
		tv=0.0f;
		break;
	default:
		break;
	}
	if(it!=DATA_TYPE_HANDLE){
		if(it==DATA_TYPE_STRING)it=DATA_TYPE_HANDLE;
		else{
			return;
		}
	}
	switch(iFlag){
	case UniVar::univarpt:
		{
			if(iFirst<0||iFirst>(int)(GetDataLength()-sizeof(UniVar)))return;
			UniVar * pv=(UniVar *)(uv.hv+iFirst);
			if(iLen){
				if(!UniVar::ValidVar(pv))memset(pv,0,sizeof(UniVar));
				else *pv=0;
				memcpy(pv,&tv,sizeof(UniVar));
				memset(&tv,0,sizeof(UniVar));
			}
			else{
				tv=0;
				if(!UniVar::ValidVar(pv))memset(pv,0,sizeof(UniVar));
				memcpy(&tv,pv,sizeof(UniVar));
				memset(pv,0,sizeof(UniVar));
			}
		}
		break;
	case UniVar::insertblock: 
		{
			if(iFirst>GetDataLength())iFirst=GetDataLength();
			if(iFirst<0)iFirst=0;
			int iAddlen=tv.GetDataLength();
			BYTE * p1,* p2=(BYTE *)uv.hv,*p3;
			if(iAddlen==0){
				if(iLen==0||iLen>4)iAddlen=4;
				else iAddlen=iLen;
				p3=(BYTE *)&tv.uv.iv;
			}
			else {
				p3=(BYTE *)tv.uv.pv;
			}
			p1=(BYTE *)HeapAlloc(UniVar::m_hCreate,0,GetDataLength()+iAddlen);//new BYTE[GetDataLength()+iAddlen];
			if(p1){
				UniVar::m_iHeapBlock++;
				if(p2){
					memcpy(p1,p2,iFirst);
					memcpy(p1+iFirst+iAddlen,p2+iFirst,GetDataLength()-iFirst);
					HeapFree(UniVar::m_hCreate,0,p2);//delete [] p2;
					UniVar::m_iHeapBlock--;
				}
				memcpy(p1+iFirst,p3,iAddlen);
				uv.heap.handle=uv.heap.pBuffer=p1;
				SetDataLength(GetDataLength()+iAddlen);
			}
		}
		break;
	case UniVar::deleteblock: 
		if(GetDataLength()){
			if(iFirst>GetDataLength())iFirst=GetDataLength();
			if(iFirst<0)iFirst=0;
			if(iLen<0)iLen=0;
			if(iLen>GetDataLength()-iFirst)iLen=GetDataLength()-iFirst;
			if(iLen!=0){
				if(iLen==GetDataLength()){
					if(HeapFree(UniVar::m_hCreate,0,uv.bv))UniVar::m_iHeapBlock--;
					uv.heap.handle=uv.heap.pBuffer=NULL;
					SetDataLength(0);
				}
				else {
					BYTE * p1,* p2=uv.bv;
					p1=(BYTE *)HeapAlloc(UniVar::m_hCreate,0,GetDataLength()-iLen);//new BYTE[GetDataLength()+iAddlen];
					if(p1){
						UniVar::m_iHeapBlock++;
						memcpy(p1,p2,iFirst);
						memcpy(p1+iFirst,p2+iFirst+iLen,GetDataLength()-iFirst-iLen);
						if(HeapFree(UniVar::m_hCreate,0,p2))
							UniVar::m_iHeapBlock--;
						uv.heap.handle=uv.heap.pBuffer=p1;
						SetDataLength(GetDataLength()-iLen);
					}
				}
			}
		}
		break;
	case UniVar::substblock: 
		{
			if(iFirst>GetDataLength())iFirst=GetDataLength();
			if(iFirst<0)iFirst=0;
			if(iLen<0)iLen=0;
			if(iLen>GetDataLength()-iFirst)iLen=GetDataLength()-iFirst;
			int iAddlen=tv.GetDataLength();
			BYTE * p1,* p2=uv.bv,*p3;
			if(iAddlen==0){
				iAddlen=4;
				p3=(BYTE *)&tv.uv.iv;
			}
			else {
				p3=tv.uv.bv;
			}
			int iDef=iAddlen-iLen;
			ASSERT(GetDataLength()+iDef>=0);
			p1=(BYTE *)HeapAlloc(UniVar::m_hCreate,0,GetDataLength()+iDef);
			if(p1){
				UniVar::m_iHeapBlock++;
				if(p2){
					memcpy(p1,p2,iFirst);
					memcpy(p1+iFirst+iAddlen,p2+iFirst+iLen,GetDataLength()-iFirst-iLen);
					if(HeapFree(UniVar::m_hCreate,0,p2))UniVar::m_iHeapBlock--;
				}
				uv.heap.handle=uv.heap.pBuffer=p1;
				memcpy(p1+iFirst,p3,iAddlen);
				SetDataLength(GetDataLength()+iDef);
			}
		}
		break;
	case UniVar::copyblock: 
		if(GetDataLength()){
			if(!iLen)return ;
			int direct=1;
			if(iLen<0){
				iLen=-iLen;
				direct=0;
			};
			if(iFirst<0||iFirst+iLen>GetDataLength())return;
			BYTE * p2=uv.bv;
			switch(tv.it){
			case DATA_TYPE_HANDLE	:
				if(direct){
					tv.SetValue((void *)(p2+iFirst),iLen);
				}
				else{
					if(tv.GetDataLength()<iLen)return;
					memcpy(uv.bv+iFirst,tv.uv.bv,iLen);
				}
				break;
			case DATA_TYPE_STRING	:
				{
					if(direct){
						bool bok=false;
						for(int i=iFirst;i<iLen+iFirst;i++){
							if(p2[i]=='\0'){
								bok=true;
								break;
							}
						}
						if(bok){
							tv=(char *)(p2+iFirst);
							break;
						}
					}
					else{
						if(!tv.GetDataLength())return;
						if(tv.GetDataLength()<iLen){
							memcpy(p2+iFirst,tv.uv.bv,tv.GetDataLength());
						}
						else{
							memcpy(p2+iFirst,tv.uv.bv,iLen);
						}
					}
				}
				break;
			case DATA_TYPE_INT		:
			case DATA_TYPE_DWORD	:
				if(direct){
					if(iLen<4){
						tv.uv.iv=0;
						memcpy((BYTE *)&tv.uv.iv,p2+iFirst,iLen);
					}
					else {
						tv.uv.iv=*((int*)(p2+iFirst));
					}
				}
				else{
					if(tv.GetDataLength()<=4){
						memcpy(p2+iFirst,(BYTE *)&tv.uv,iLen);
					}
				}
				break;
			case DATA_TYPE_FLOAT	:
				if(direct){
					tv.uv.dv=*((double*)(p2+iFirst));
				}
				else{
					if(iLen!=8)return;
					memcpy(p2+iFirst,(BYTE *)&tv.uv,iLen);
				}
				break;
			default:
				break;
			}
		}
		break;
	}
}

const int UniVar::operator =(const UniVar & ttv)
{
	ClearData();
	if(ttv.dwCheckL){
		Uninew(ttv.dwCheckL,ttv.it);
		if(uv.bv)memcpy(uv.bv,ttv.uv.bv,ttv.dwCheckL);
		btmust=ttv.btmust;
		inout=ttv.inout;
	}
	else {
		memcpy(this,&ttv,sizeof(UniVar));
	};
	return 1;
};

UniVar::UniVar(UniVar * ptv)
{
	if(ptv->dwCheckL){
		Uninew(ptv->dwCheckL,ptv->it);
		if(uv.bv)memcpy(uv.bv,ptv->uv.bv,ptv->dwCheckL);
		btmust=ptv->btmust;
		inout=ptv->inout;
	}
	else {
		memcpy(this,ptv,sizeof(UniVar));
	};
};

UniVar::UniVar(int i,UniVar & tv)
{
	if(i==tv.GetType()){
		if(tv.GetDataLength()){
			Uninew(tv.GetDataLength(),tv.it);
			if(uv.bv)memcpy(uv.bv,tv.uv.bv,tv.GetDataLength());
			btmust=tv.btmust;
			inout=tv.inout;
		}
		else {
			memcpy(this,&tv,sizeof(UniVar));
		};
	}
	else {
		dwCheckL=0;
		switch(i){
		case DATA_TYPE_INT:*this=(int)tv;break;
		case DATA_TYPE_FLOAT:*this=(double)tv;break;
		case DATA_TYPE_DWORD:*this=(DWORD)tv;break;
		case DATA_TYPE_STRING:*this=(char *)tv;break;
		case DATA_TYPE_HANDLE:*this=UniVar((void *)tv,tv.GetDataLength());break;
		}
	}
};

BOOL UniVar::ValidVar(UniVar * p){
	if(p->it>=DATA_TYPE_INT&&p->it<DATA_TYPE_MAX){
		if(p->it==DATA_TYPE_HANDLE||p->it==DATA_TYPE_STRING){
			if(p->uv.heap.handle==p->uv.heap.pBuffer)return TRUE;
			return FALSE;
		}
		else return TRUE;
	}
	else return FALSE;
}

UniVar::UniVar(UniVar & tv)
{
	if(tv.GetDataLength()){
		Uninew(tv.GetDataLength(),tv.it);
		if(uv.bv)memcpy(uv.bv,tv.uv.bv,tv.GetDataLength());
		btmust=tv.btmust;
		inout=tv.inout;
	}
	else {
		memcpy(this,&tv,sizeof(UniVar));
	};
};

UniVar::UniVar(UniVar &tv,int btm,int io)
{
	if(tv.GetDataLength()){
		Uninew(tv.GetDataLength(),tv.it);
		if(uv.bv)memcpy(uv.bv,tv.uv.bv,tv.GetDataLength());
		btmust=btm;
		inout=io;
	}
	else {
		memcpy(this,&tv,sizeof(UniVar));
		btmust=btm;
		inout=io;
	};
};

UniVar::UniVar(char * s)
{
	btmust=0;
	inout=0;
	if(s){
		int len=strlen(s)+1;
		Uninew(len,DATA_TYPE_STRING);
		if(uv.bv)memcpy(uv.bv,s,len);
	}
	else {
		Uninew(1,DATA_TYPE_STRING);
		uv.cv[0]='\0';
	}
}

UniVar::UniVar(LPCTSTR s)
{
	btmust=0;
	inout=0;
	if(s){
		int len=strlen(s)+1;
		Uninew(len,DATA_TYPE_STRING);
		if(uv.bv)memcpy(uv.bv,s,len);
	}
	else {
		Uninew(1,DATA_TYPE_STRING);
		if(uv.bv)uv.cv[0]='\0';
	}
};
	
UniVar::UniVar(CString & s)
{
	btmust=0;
	inout=0;
	if(!s.IsEmpty()){
		int len=s.GetLength()+1;
		Uninew(len,DATA_TYPE_STRING);
		if(uv.bv)memcpy(uv.bv,(LPCTSTR)s,len);
	}
	else {
		Uninew(1,DATA_TYPE_STRING);
		if(uv.bv)uv.cv[0]='\0';
	}
};

UniVar::UniVar(void * p,int i)
{
	int j=i&0x00ffffff;
	if(j){
		Uninew(j,DATA_TYPE_HANDLE);
		btmust=0;
		inout=0;
		if(p){
			if(uv.bv)memcpy(uv.bv,p,j);
		}
		else {
			if(uv.bv)memset(uv.bv,0,j);
		}
	}
	else {
		memset(this,0,sizeof(UniVar));
		it=DATA_TYPE_HANDLE;
	}
};

void UniVar::SetValue(void * p,int i)
{
	ClearData();
	int j=i&0x00ffffff;
	if(j){
		Uninew(j,DATA_TYPE_HANDLE);
		btmust=0;
		inout=0;
		if(p){
			if(uv.bv)memcpy(uv.bv,p,j);
		}
		else{
			if(uv.bv)memset(uv.bv,0,j);
		}
	}
	else {
		if(uv.bv)memset(this,0,sizeof(UniVar));
		it=DATA_TYPE_HANDLE;
	}
};

void UniVar::Convert(int oit)
{
	if(oit==it)return ;
	switch(oit){
	case DATA_TYPE_INT:
		if(it==DATA_TYPE_FLOAT)*this=((int)uv.dv);
		else if(it==DATA_TYPE_DWORD)*this=((int)uv.pv);
		else *this=(uv.iv);
		break;
	case DATA_TYPE_FLOAT:
		if(it==DATA_TYPE_INT)*this=((double)uv.iv);
		else if(it==DATA_TYPE_DWORD)*this=((double)uv.pv);
		else *this=(0.0f);
		break;
	case DATA_TYPE_DWORD:
		if(it==DATA_TYPE_INT)*this=((DWORD)uv.iv);
		else if(it==DATA_TYPE_FLOAT)*this=((DWORD)uv.dv);
		else *this=(uv.pv);
		break;
	case DATA_TYPE_STRING:
		if(it==DATA_TYPE_HANDLE)*this=((DWORD)uv.cv);
		else *this=("");
		break;
	case DATA_TYPE_HANDLE:
		if(it==DATA_TYPE_STRING)it=DATA_TYPE_HANDLE;
		else *this=UniVar((void *)NULL,0);
		break;
	default:
		*this=(0);
		break;
	}
}

void UniVar::SetData(UniVar & tv)
{
	if(it==DATA_TYPE_HANDLE){
		if(dwCheckL==tv.dwCheckL)memcpy(uv.cv,tv.uv.cv,dwCheckL);
		else memset(uv.cv,0,GetDataLength());
	}
	else if(it==tv.it)*this=tv;
	else {
		switch(it){
		case DATA_TYPE_INT:*this=(int)tv;break;
		case DATA_TYPE_FLOAT:*this=(double)tv;break;
		case DATA_TYPE_DWORD:*this=(DWORD)tv;break;
		case DATA_TYPE_STRING:*this="";break;
		}
	}
};

void UniVar::SetData(int i,UniVar & tv)
{
	if(i==tv.it)*this=tv;
	else {
		switch(i){
		case DATA_TYPE_INT:*this=(int)tv;break;
		case DATA_TYPE_FLOAT:*this=(double)tv;break;
		case DATA_TYPE_DWORD:*this=(DWORD)tv;break;
		case DATA_TYPE_STRING:*this="";break;
		case DATA_TYPE_HANDLE:*this=UniVar((void *)tv,tv.GetDataLength());break;
		default:*this=(0);break;
		}
	}
}

LPSTR UniVar::ToA(char * szCHString)
{
	if(szCHString==NULL){
		char szBuffer[200];
		switch(it){
		case DATA_TYPE_INT: sprintf(szBuffer,ITOSTRING_STRING,uv.iv);*this=szBuffer;return uv.cv;
		case DATA_TYPE_FLOAT: sprintf(szBuffer,FTOSTRING_STRING,uv.dv);*this=szBuffer;return uv.cv;
		case DATA_TYPE_DWORD: sprintf(szBuffer,XTOSTRING_STRING,uv.pv);*this=szBuffer;return uv.cv;
		case DATA_TYPE_STRING: return uv.cv;
		case DATA_TYPE_HANDLE: 
			{
				for(int i=0;i<GetDataLength();i++){
					if(uv.cv[i]==0){
						CString cs=(char *)(uv.cv);
						*this=UniVar(cs);
						return uv.cv;
					}
				}
			}
		default : *this=("");return uv.cv;
		};
	}
	else {
		char szBuffer[200];
		switch(it){
		case DATA_TYPE_INT: sprintf(szBuffer,szCHString,uv.iv);*this=szBuffer;return uv.cv;
		case DATA_TYPE_FLOAT: sprintf(szBuffer,szCHString,uv.dv);*this=szBuffer;return uv.cv;
		case DATA_TYPE_DWORD: sprintf(szBuffer,szCHString,uv.pv);*this=szBuffer;return uv.cv;
		case DATA_TYPE_STRING: return uv.cv;
		case DATA_TYPE_HANDLE: 
		default : *this=("");return uv.cv;
		};
	}
};

BOOL UniVar::IsSame(UniVar & u)
{
	if(it!=u.it)return FALSE;
	switch(it){
	case DATA_TYPE_STRING: 
	case DATA_TYPE_HANDLE: 
		if(GetDataLength()!=u.GetDataLength())return FALSE;
		if(GetDataLength()==0)return TRUE;
		return (!memcmp((void *)uv.cv,(void *)u.uv.cv,GetDataLength()));
	case DATA_TYPE_FLOAT:
		return (uv.dv==u.uv.dv);
	case DATA_TYPE_INT: 
	case DATA_TYPE_DWORD:
	default:
		return (uv.iv==u.uv.iv);
	}
}

BOOL UniVar::IsSame(UniVar * pu)
{
	if(it!=pu->it)return FALSE;
	switch(it){
	case DATA_TYPE_STRING: 
	case DATA_TYPE_HANDLE: 
		if(GetDataLength()!=pu->GetDataLength())return FALSE;
		return (!memcmp((void *)uv.cv,(void *)pu->uv.cv,GetDataLength()));
	case DATA_TYPE_FLOAT:
		return (uv.dv==pu->uv.dv);
	case DATA_TYPE_INT: 
	case DATA_TYPE_DWORD:
	default:
		return (uv.iv==pu->uv.iv);
	}
}