calcformule.cpp

我的简易编译器终于在花了近20个工作日后完成了。按照设计是做成一个FormulaEx.dll

	while( true )
		//( m_sFunctionList[nFuncNo].nPrmSum == -1 
		//  || prmNo < m_sFunctionList[nFuncNo].nPrmSum )
		
	{
		prmNo ++;
		str = Formula();
		slOperand.AddTail(str);
		str = m_lpGetWord->getAWord();
		if( str.IsEmpty() || ( str[0] != ',' && str[0] != ')') ) RETURNEMPTY;
		if( str[0] == ')'){
			//m_lpGetWord->SetPreword(str);
			break;
		}
	}
	//str = m_lpGetWord->getAWord();
	if( str.IsEmpty() || str[0] != ')') RETURNEMPTY;
	if( m_sFunctionList[nFuncNo].nPrmSum != -1 
		//&& prmNo != m_sFunctionList[nFuncNo].nPrmSum) RETURNEMPTY;
		&& prmNo < m_sFunctionList[nFuncNo].nPrmSum) RETURNEMPTY;

	str = OperateFunc(slOperand,m_sFunctionList[nFuncNo].nFuncID);
	return str;	
}

CString CCalcFormula::Operate(const CString & operand,const CString & operand2,int optID)
{
	CString str("");

	bool bop = CRegularOpt::IsTrue(operand), bop2 = CRegularOpt::IsTrue(operand2);
	switch(optID){
	case OP_OR:
		if(bop||bop2) return CString("1");
		return CString("0");
	case OP_AND:
		if(bop&&bop2) return CString("1");
		return CString("0");
	}
	
	if( !CRegularOpt::IsNumber(operand) || !CRegularOpt::IsNumber(operand2)){
		CString str1(operand);
		CString str2(operand2);
	    str1 = CRegularOpt::TrimString(str1);
	    str2 = CRegularOpt::TrimString(str2);

		int res = str1.Compare(str2);

		switch(optID){
		case OP_ADD:
		case OP_MUL:{
			str.Format("\"%s%s\"", str1 , str2);
			return str;
					}
		case OP_EQ:
			if( res ==0) return CString("1");
			return CString("0");
		case OP_BG:
			if( res > 0) return CString("1");
			return CString("0");
		case OP_LT:
			if( res < 0) return CString("1");
			return CString("0");
		case OP_EL:
			if( res <=0) return CString("1");
			return CString("0");
		case OP_EB:
			if( res >=0) return CString("1");
			return CString("0");
		case OP_NE:
			if( res !=0) return CString("1");
			return CString("0");
		case OP_LMOV:
			if( CRegularOpt::IsNumber(operand2) ){
				int nP2 = atoi (operand2);

				if(nP2>=0 && str1.GetLength() > nP2){
					str = str1.Mid(0,str1.GetLength() - nP2);
					return str;
				}
			}
			RETURNEMPTY;
		case OP_RMOV:
			if( CRegularOpt::IsNumber(operand2) ){
				int nP2 = atoi (operand2);
				if(nP2>=0 && str1.GetLength() > nP2){
					str = str1.Mid(nP2);
					return str;
				}
			}
			RETURNEMPTY;
		case OP_LIKE:
			if(CRegularOpt::IsMatch(operand,operand2)) return CString("1");
			return CString("0");
		}
		RETURNEMPTY;
	}

	double dbop = atof(operand);double dbop2 = atof(operand2);
	switch(optID){
	case OP_ADD:
		str.Format("%f",dbop+dbop2);
		return str;
	case OP_SUB:
		str.Format("%f",dbop-dbop2);
		return str;
	case OP_MUL:
		str.Format("%f",dbop*dbop2);
		return str;
	case OP_DIV:
		if( dbop2 == 0.f)
			return CString("0");
		str.Format("%f",dbop/dbop2);
		return str;
	case OP_EQ:
		if( dbop==dbop2) return CString("1");
		return CString("0");
	case OP_BG:
		if( dbop>dbop2) return CString("1");
		return CString("0");
	case OP_LT:
		if(dbop<dbop2) return CString("1");
		return CString("0");
	case OP_EL:
		if(dbop<=dbop2) return CString("1");
		return CString("0");
	case OP_EB:
		if(dbop>=dbop2) return CString("1");
		return CString("0");
	case OP_NE:
		if(dbop!=dbop2) return CString("1");
		return CString("0");
	case OP_POWER:
		str.Format("%f",pow(dbop,dbop2));
		return str;
	case OP_LMOV:{
		int nP= int(dbop);
		int nP2 = int (dbop2);
		str.Format("%d",nP>>nP2);
				 }
		return str;
	case OP_RMOV:{
		int nP= int(dbop);
		int nP2 = int (dbop2);
		str.Format("%d",nP<<nP2);
				 }
		return str;
	case OP_LIKE:
		if(CRegularOpt::IsMatch(operand,operand2)) return CString("1");
		return CString("0");
	}	

	RETURNEMPTY;
}

CString CCalcFormula::OperateFunc(const CStringList & slOperand,int funcID)
{
	if(slOperand.IsEmpty()){
		//todo: no parameter function
		RETURNEMPTY;
	}
	CString str(""),tempstr;
	double dbtemp(.0);
	POSITION p;
	switch(funcID){
	case FUNC_AVE :// 100
		p = slOperand.GetHeadPosition();
		while(p != NULL){
			dbtemp += atof(slOperand.GetNext(p));
		}
		if (slOperand.GetCount()>0) 
			str.Format("%f",dbtemp/slOperand.GetCount());
		else
			str = "0";
		return str;

	case FUNC_BYTE:// 101
		tempstr = slOperand.GetHead();
		if(CRegularOpt::IsNumber(tempstr)){
			int nbit = atoi(slOperand.GetTail());
			str.Format("%c",CRegularOpt::GetNumbtye(tempstr,nbit));
		}else{
			int sl = tempstr.GetLength();
			int nbit = atoi(slOperand.GetTail());
			if( nbit >=0 && nbit < sl) 
				str = tempstr[nbit];
			else 
				str = "";
		}
		return str;

	case FUNC_MATCH:
		tempstr = slOperand.GetHead();
		str = slOperand.GetTail();
		if(CRegularOpt::IsMatch(tempstr,str)) return CString("1");
		return CString("0");

	case FUNC_CAPITAL:// 102
		{
			p = slOperand.GetHeadPosition();
			if(p==NULL) RETURNEMPTY;
			tempstr = slOperand.GetNext(p);
			int nT = 0;
			if(p!=NULL)
				nT = atoi(slOperand.GetNext(p));
			if( (nT==0) && !CRegularOpt::IsNumber(tempstr) ) RETURNEMPTY;
			str = CRegularOpt::Capitalization(tempstr,nT);
		}
		return str;
	case FUNC_MAX:// 103
		p = slOperand.GetHeadPosition();
		if(p==NULL) RETURNEMPTY;

	    dbtemp = atof(slOperand.GetNext(p));
		while(p != NULL){
			float tMidF = atof(slOperand.GetNext(p));
			if (dbtemp < tMidF)
				dbtemp = tMidF;
		}
		str.Format("%f",dbtemp);	
		return str;
/*
	case FUNC_IN:// 112
		p = slOperand.GetHeadPosition();
		tempstr = slOperand.GetNext(p);

		while(p != NULL){
			str = slOperand.GetNext(p);
			if (tempstr == str)
				return CString("1");
		}
		return CString("0");
*/
	case FUNC_MIN:// 104
		p = slOperand.GetHeadPosition();
	    dbtemp = atof(slOperand.GetNext(p));
		while(p != NULL){
			float tMidF = atof(slOperand.GetNext(p));
			if (dbtemp > tMidF)
				dbtemp = tMidF;
		}
		str.Format("%f",dbtemp);
		return str;

	case FUNC_COUNT:// 112
		str.Format("%d",slOperand.GetCount());
		return str;

	case FUNC_SUM:// 105	
		p = slOperand.GetHeadPosition();
		while(p != NULL){
			dbtemp += atof(slOperand.GetNext(p));
		}
		str.Format("%f",dbtemp);
		return str;

	case FUNC_STDDEV:// 133	
		{
			int nCount(0);
			p = slOperand.GetHeadPosition();
			while(p != NULL){
				dbtemp += atof(slOperand.GetNext(p));
				nCount++;
			}
			if(nCount<2) return CString("0");
			double dbAvg = dbtemp/nCount;
			dbtemp = .0;
			p = slOperand.GetHeadPosition();
			while(p != NULL){
				double dtp = atof(slOperand.GetNext(p)) - dbAvg;
				dbtemp += dtp*dtp; 
			}
			dbtemp = sqrt(dbtemp/double(nCount-1));
			str.Format("%f",dbtemp);
			return str;
		}
	case FUNC_STRCAT:// 106
		{
			p = slOperand.GetHeadPosition();
			str = '\"';
			while(p != NULL){
				CString str1(slOperand.GetNext(p));
				str1 = CRegularOpt::TrimString(str1);
				str +=str1;
			}
			str +='\"';
			return str;
		}
	case FUNC_SUBSTR:{
			int nS = slOperand.GetCount();
			if (nS < 1) RETURNEMPTY;
			p = slOperand.GetHeadPosition();
			CString str1(slOperand.GetNext(p));
			if ((nS == 1) || str1.IsEmpty()) return str1;
			str = slOperand.GetNext(p);
			int nStart(0),nLength;
			if(!str.IsEmpty()) nStart = atoi(str);
			if(nS>2){
				tempstr = slOperand.GetNext(p);
				nLength = atoi(tempstr);
			}
			else 
				nLength = str1.GetLength();

			if(nLength<=0) nLength = 1;
			tempstr = str1.Mid(nStart,nLength);
			str1  = '"' +tempstr + '"';
			return str1;
					 }

	case FUNC_FIND:{ //index
			int nS = slOperand.GetCount();
			if (nS < 2) return "-1";
			p = slOperand.GetHeadPosition();
			str = slOperand.GetNext(p);
			tempstr = slOperand.GetNext(p);
			int nStart(0);
			if(p!=NULL){
				CString str1(slOperand.GetNext(p));
				if(CRegularOpt::IsNumber(str1))
					nStart = atoi(str1)>0?atoi(str1):0;
			}
			tempstr = CRegularOpt::TrimString(tempstr);
			str = CRegularOpt::TrimString(str);
			nS = tempstr.Find(str,nStart); 
			str.Format("%d",nS);
			return str;
					 }
	case FUNC_FREQUENCE:{
			int nS = slOperand.GetCount();
			if (nS < 2) return "-1";
			p = slOperand.GetHeadPosition();
			str = slOperand.GetNext(p);
			tempstr = slOperand.GetNext(p);
			tempstr = CRegularOpt::TrimString(tempstr);
			str = CRegularOpt::TrimString(str);
			
			int nSt(0),sl=str.GetLength(),nC(0);
			nSt = tempstr.Find(str,nSt);
			while(nSt>0){
				nC++;
				nSt+=sl;
				nSt = tempstr.Find(str,nSt);
			}

			str.Format("%d",nC);
			return str;

						}
	case FUNC_ROUND:{
			int nS = slOperand.GetCount();
			p = slOperand.GetHeadPosition();
			CString str1(slOperand.GetNext(p));
			int nPrecision = 0;
			if( nS > 1)
				nPrecision = atoi(slOperand.GetNext(p));
			return CRegularOpt::PrecisionNum(str1,nPrecision);
					}

	case FUNC_LN:
		{
			tempstr = slOperand.GetHead();
			if(!CRegularOpt::IsNumber(tempstr)) RETURNEMPTY;
			float af = atof(tempstr);
			af = log(af);
			str.Format("%f",af);
			return str;
		}
	case FUNC_LOG:
		{
			tempstr = slOperand.GetHead();
			if(!CRegularOpt::IsNumber(tempstr)) RETURNEMPTY;
			float af = atof(tempstr);
			af = log10(af);
			str.Format("%f",af);
			return str;
		}
	case FUNC_SIN://sin
		{
			tempstr = slOperand.GetHead();
			if(!CRegularOpt::IsNumber(tempstr)) RETURNEMPTY;
			float af = atof(tempstr);
			af = sin(af);
			str.Format("%f",af);
			return str;
		}
	case FUNC_COS://cos
		{
			tempstr = slOperand.GetHead();
			if(!CRegularOpt::IsNumber(tempstr)) RETURNEMPTY;
			float af = atof(tempstr);
			af = cos(af);
			str.Format("%f",af);
			return str;
		}
	case FUNC_TAN://tan
		{
			tempstr = slOperand.GetHead();
			if(!CRegularOpt::IsNumber(tempstr)) RETURNEMPTY;
			float af = atof(tempstr);
			af = tan(af);
			str.Format("%f",af);
			return str;
		}
	case FUNC_CTAN://ctan
		{
			tempstr = slOperand.GetHead();
			if(!CRegularOpt::IsNumber(tempstr)) RETURNEMPTY;
			float af = atof(tempstr);
			af = tanh(af);
			str.Format("%f",af);
			return str;
		}
	case FUNC_INT://取整
		{
			tempstr = slOperand.GetHead();
			if(CRegularOpt::IsNumber(tempstr)){
				float af = atof(tempstr);
				str.Format("%d",int(af));
			}else
				str = "0";
			return str;
		}
	case FUNC_FRAC://取小数
		{
			tempstr = slOperand.GetHead();
			if(CRegularOpt::IsNumber(tempstr)){
				float af = atof(tempstr);
				str.Format("%f",af - int(af));
			}else
				str = "0";
			return str;
		}

	case FUNC_EXP:
		{
			tempstr = slOperand.GetHead();
			if(!CRegularOpt::IsNumber(tempstr)) RETURNEMPTY;
			float af = atof(tempstr);
			af = exp(af);
			str.Format("%f",af);
			return str;
		}
	case FUNC_SQRT:
		{
			tempstr = slOperand.GetHead();
			if(!CRegularOpt::IsNumber(tempstr)) RETURNEMPTY;
			float af = atof(tempstr);
			af = sqrt(af);
			str.Format("%f",af);
			return str;
		}