1009 lines
26 KiB
C++
1009 lines
26 KiB
C++
#include "stdafx.h"
|
|
|
|
#include <math.h>
|
|
#include <float.h>
|
|
|
|
#include "KTExpressCalc.h"
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[]=__FILE__;
|
|
#define new DEBUG_NEW
|
|
#endif
|
|
|
|
#define EPS 1.0e-10
|
|
|
|
#ifndef _ttof
|
|
#ifdef _UNICODE
|
|
#define _ttof(s) wcstod(s, NULL)
|
|
#else
|
|
#define _ttof(s) strtod(s, NULL)
|
|
#endif // _UNICODE
|
|
#endif // _ttof
|
|
|
|
typedef double (* lpfnCalcFun1)(double);
|
|
typedef double (* lpfnCalcFun2)(double, double);
|
|
|
|
static double _or(double dX1, double dX2) { return (fabs(dX1) > EPS || fabs(dX2) > EPS); }
|
|
static double _xor(double dX1, double dX2) { return (((fabs(dX1) > EPS ? 1 : -1) * (fabs(dX2) > EPS ? 1 : -1) < 0) ? 1 : 0); }
|
|
static double _and(double dX1, double dX2) { return (fabs(dX1) > EPS && fabs(dX2) > EPS); }
|
|
static double _not(double dX) { return (fabs(dX) < EPS); }
|
|
static double greatthan(double dX1, double dX2) { return (dX1 > dX2); }
|
|
static double lessthan(double dX1, double dX2) { return (dX1 < dX2); }
|
|
static double equal(double dX1, double dX2) { return (fabs(dX1 - dX2) < EPS); }
|
|
static double greatequal(double dX1, double dX2){ return (dX1 >= dX2); }
|
|
static double lessequal(double dX1, double dX2) { return (dX1 <= dX2); }
|
|
static double notequal(double dX1, double dX2) { return (fabs(dX1 - dX2) > EPS); }
|
|
static double add(double dX1, double dX2) { return (dX1 + dX2); }
|
|
static double subtract(double dX1, double dX2) { return (dX1 - dX2); }
|
|
static double multiple(double dX1, double dX2) { return (dX1 * dX2); }
|
|
static double divide(double dX1, double dX2) { return (dX1 / dX2); }
|
|
static double integer(double dX) { return (long(dX)); }
|
|
static double cot(double dX) { return (1.0 / tan(dX)); }
|
|
static double factorial(double dX) { return dX;}
|
|
|
|
static double f_mod(double dX1, double dX2) { return fmod(dX1, dX2);}
|
|
static double f_pow(double dX1, double dX2) { return pow(dX1, dX2);}
|
|
static double f_abs(double dX) { return fabs(dX); }
|
|
static double f_sqrt(double dX) { return sqrt(dX); }
|
|
static double f_exp(double dX) { return exp(dX); }
|
|
static double f_log(double dX) { return log(dX); }
|
|
static double f_log10(double dX) { return log10(dX); }
|
|
static double f_sin(double dX) { return sin(dX); }
|
|
static double f_cos(double dX) { return cos(dX); }
|
|
static double f_tan(double dX) { return tan(dX); }
|
|
static double f_cot(double dX) { return cot(dX); }
|
|
static double f_asin(double dX) { return asin(dX); }
|
|
static double f_acos(double dX) { return acos(dX); }
|
|
static double f_atan(double dX) { return atan(dX); }
|
|
static double f_sinh(double dX) { return sinh(dX); }
|
|
static double f_cosh(double dX) { return cosh(dX); }
|
|
static double f_tanh(double dX) { return tanh(dX); }
|
|
|
|
static KTExpressCalc::CElement::COperator g_pOperator[] =
|
|
{
|
|
{_T("("), KTExpressCalc::eOpeLeftPthis, KTExpressCalc::ePriLeftPthis, 0, NULL},
|
|
{_T(")"), KTExpressCalc::eOpeRightPthis, KTExpressCalc::ePriRightPthis,0, NULL},
|
|
|
|
{_T("IF"), KTExpressCalc::eOpeIf, KTExpressCalc::ePriIfElse, 0, NULL},
|
|
{_T("THEN"), KTExpressCalc::eOpeThen, KTExpressCalc::ePriIfElse, 0, NULL},
|
|
{_T("ELSE"), KTExpressCalc::eOpeElse, KTExpressCalc::ePriIfElse, 0, NULL},
|
|
|
|
{_T("OR"), KTExpressCalc::eOpeOr, KTExpressCalc::ePriOr, 2, _or},
|
|
{_T("XOR"), KTExpressCalc::eOpeXor, KTExpressCalc::ePriOr, 2, _xor},
|
|
{_T("AND"), KTExpressCalc::eOpeAnd, KTExpressCalc::ePriAnd, 2, _and},
|
|
{_T("NOT"), KTExpressCalc::eOpeNot, KTExpressCalc::ePriNot, 1, _not},
|
|
|
|
{_T(">"), KTExpressCalc::eOpeGreatThan, KTExpressCalc::ePriCompare, 2, greatthan},
|
|
{_T("<"), KTExpressCalc::eOpeLessThan, KTExpressCalc::ePriCompare, 2, lessthan},
|
|
{_T("="), KTExpressCalc::eOpeEqual, KTExpressCalc::ePriCompare, 2, equal},
|
|
{_T(">="), KTExpressCalc::eOpeGreatEqual, KTExpressCalc::ePriCompare, 2, greatequal},
|
|
{_T("<="), KTExpressCalc::eOpeLessEqual, KTExpressCalc::ePriCompare, 2, lessequal},
|
|
{_T("!="), KTExpressCalc::eOpeNotEqual, KTExpressCalc::ePriCompare, 2, notequal},
|
|
|
|
{_T("+"), KTExpressCalc::eOpeAdd, KTExpressCalc::ePriSum, 2, add},
|
|
{_T("-"), KTExpressCalc::eOpeSubtract, KTExpressCalc::ePriSum, 2, subtract},
|
|
{_T("*"), KTExpressCalc::eOpeMultiply, KTExpressCalc::ePriMultiple, 2, multiple},
|
|
{_T("/"), KTExpressCalc::eOpeDivide, KTExpressCalc::ePriMultiple, 2, divide},
|
|
{_T("%"), KTExpressCalc::eOpeRemainder, KTExpressCalc::ePriMultiple, 2, f_mod},
|
|
{_T("^"), KTExpressCalc::eOpePower, KTExpressCalc::ePriPower, 2, f_pow},
|
|
{_T("!"), KTExpressCalc::eOpeFactorial, KTExpressCalc::ePriFactorial, -1, factorial},
|
|
|
|
{_T("int"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, integer},
|
|
{_T("abs"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_abs},
|
|
{_T("sqrt"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_sqrt},
|
|
{_T("exp"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_exp},
|
|
{_T("ln"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_log},
|
|
{_T("log"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_log10},
|
|
{_T("sin"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_sin},
|
|
{_T("cos"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_cos},
|
|
{_T("tan"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_tan},
|
|
{_T("cot"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_cot},
|
|
{_T("asin"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_asin},
|
|
{_T("acos"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_acos},
|
|
{_T("atan"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_atan},
|
|
{_T("sinh"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_sinh},
|
|
{_T("cosh"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_cosh},
|
|
{_T("tanh"), KTExpressCalc::eOpeFunction, KTExpressCalc::ePriFunction, 1, f_tanh},
|
|
};
|
|
|
|
KTExpressCalc::CElement::CElement()
|
|
{
|
|
m_eEleType = KTExpressCalc::eEleUnknown;
|
|
|
|
m_cOperate.m_pszOperate = NULL;
|
|
m_cOperate.m_eOpeType = KTExpressCalc::eOpeUnknown;
|
|
m_cOperate.m_ePriType = KTExpressCalc::ePriUnknown;
|
|
m_cOperate.m_iEleNum = 0;
|
|
m_cOperate.m_pfnCalc = NULL;
|
|
|
|
m_pszVariable = NULL;
|
|
|
|
m_dValue = 0.0;
|
|
}
|
|
|
|
KTExpressCalc::CElement::CElement(const KTExpressCalc::CElement& cEle)
|
|
{
|
|
m_eEleType = KTExpressCalc::eEleUnknown;
|
|
m_cOperate.m_pszOperate = NULL;
|
|
m_cOperate.m_eOpeType = KTExpressCalc::eOpeUnknown;
|
|
m_cOperate.m_ePriType = KTExpressCalc::ePriUnknown;
|
|
m_cOperate.m_iEleNum = 0;
|
|
m_cOperate.m_pfnCalc = NULL;
|
|
m_pszVariable = NULL;
|
|
m_dValue = 0.0;
|
|
|
|
(*this) = cEle;
|
|
}
|
|
|
|
KTExpressCalc::CElement::~CElement()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void KTExpressCalc::CElement::Clear()
|
|
{
|
|
if (m_eEleType == KTExpressCalc::eEleVariable && m_pszVariable != NULL)
|
|
{
|
|
delete [] m_pszVariable;
|
|
m_pszVariable = NULL;
|
|
}
|
|
|
|
m_eEleType = KTExpressCalc::eEleUnknown;
|
|
|
|
m_cOperate.m_pszOperate = NULL;
|
|
m_cOperate.m_eOpeType = KTExpressCalc::eOpeUnknown;
|
|
m_cOperate.m_ePriType = KTExpressCalc::ePriUnknown;
|
|
m_cOperate.m_iEleNum = 0;
|
|
m_cOperate.m_pfnCalc = NULL;
|
|
|
|
m_dValue = 0.0;
|
|
}
|
|
|
|
KTExpressCalc::CElement& KTExpressCalc::CElement::operator=(const KTExpressCalc::CElement& cEle)
|
|
{
|
|
Clear();
|
|
|
|
m_eEleType = cEle.m_eEleType;
|
|
|
|
switch (m_eEleType)
|
|
{
|
|
case KTExpressCalc::eEleConstant: // 数值
|
|
m_dValue = cEle.m_dValue;
|
|
break;
|
|
case KTExpressCalc::eEleVariable: // 变量
|
|
m_pszVariable = _tcsdup(cEle.m_pszVariable);
|
|
break;
|
|
case KTExpressCalc::eEleOperate: // 操作符
|
|
CopyMemory(&m_cOperate, &(cEle.m_cOperate), sizeof(COperator));
|
|
break;
|
|
}
|
|
|
|
return (*this);
|
|
}
|
|
|
|
BOOL KTExpressCalc::CElement::SetElement(CString sElement, BOOL bConstant)
|
|
{
|
|
Clear();
|
|
|
|
// 常数
|
|
if (bConstant)
|
|
{
|
|
m_eEleType = KTExpressCalc::eEleConstant;
|
|
int iFind = sElement.Find(_T('e')) + 1;
|
|
if (iFind > 0 || (iFind = sElement.Find(_T('E')) + 1) > 0)
|
|
m_dValue = _ttof(sElement.Left(iFind)) * pow(10.0, _ttof(sElement.Mid(iFind)));
|
|
else
|
|
m_dValue = _ttof(sElement);
|
|
return TRUE;
|
|
}
|
|
|
|
// 函数
|
|
int iSize = sizeof(g_pOperator) / sizeof(COperator);
|
|
for (int i = 0; i < iSize; i++)
|
|
{
|
|
if (sElement.CompareNoCase(g_pOperator[i].m_pszOperate) == 0)
|
|
{
|
|
m_eEleType = KTExpressCalc::eEleOperate;
|
|
CopyMemory(&m_cOperate, &(g_pOperator[i]), sizeof(COperator));
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
// 变量
|
|
m_eEleType = KTExpressCalc::eEleVariable;
|
|
m_pszVariable = _tcsdup(sElement);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
|
|
KTExpressCalc::KTExpressCalc()
|
|
{
|
|
m_pfnGetVariable = NULL;
|
|
m_wParam = 0;
|
|
m_lParam = 0l;
|
|
|
|
m_eErrorCode = KTExpressCalc::eOk;
|
|
}
|
|
|
|
KTExpressCalc::~KTExpressCalc()
|
|
{
|
|
}
|
|
|
|
// 计算表达式
|
|
BOOL KTExpressCalc::Calculate(LPCTSTR pszExpress, double& dResult)
|
|
{
|
|
dResult = 0.0;
|
|
m_eErrorCode = KTExpressCalc::eOk;
|
|
|
|
CListElement lstElement;
|
|
|
|
OnCreateElementList(pszExpress, lstElement);
|
|
if (lstElement.IsEmpty())
|
|
m_eErrorCode = KTExpressCalc::eNullExpress;
|
|
|
|
if (m_eErrorCode != KTExpressCalc::eOk)
|
|
return FALSE;
|
|
|
|
OnCalcElementList(lstElement, dResult);
|
|
|
|
if (m_eErrorCode != KTExpressCalc::eOk)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// 创建元素列表
|
|
BOOL KTExpressCalc::OnCreateElementList(CString sExpress, CListElement& lstElement)
|
|
{
|
|
CElement cElement;
|
|
|
|
int i = 0, iStart;
|
|
int iLen = sExpress.GetLength();
|
|
|
|
TCHAR ch;
|
|
CString sVariable;
|
|
BOOL bExp, bSign, bPoint, bDigit;
|
|
while (i < iLen)
|
|
{
|
|
iStart = i;
|
|
bExp = FALSE;
|
|
bSign = FALSE;
|
|
bPoint = FALSE;
|
|
bDigit = FALSE;
|
|
|
|
ch = sExpress[i++];
|
|
|
|
// 去除空格
|
|
if (ch == _T(' '))
|
|
continue;
|
|
|
|
// 判断是否是数字
|
|
if (_istdigit(ch) || (bPoint = (ch == _T('.'))))
|
|
{
|
|
for (; i < iLen; i++)
|
|
{
|
|
ch = sExpress[i];
|
|
|
|
if (_istdigit(ch))
|
|
{
|
|
bDigit = TRUE;
|
|
continue;
|
|
}
|
|
|
|
if (bExp)
|
|
{
|
|
if (!bPoint && (bPoint = (ch == _T('.'))))
|
|
continue;
|
|
if (!bDigit && !bPoint && !bSign && (bSign = (ch == _T('+') || ch == _T('-'))) && i+1 < iLen && _istdigit(sExpress[i+1]))
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if (!bPoint && (bPoint = (ch == _T('.'))))
|
|
continue;
|
|
if ((bExp = (ch == _T('e') || ch == _T('E'))))
|
|
{
|
|
bSign = FALSE;
|
|
bPoint = FALSE;
|
|
bDigit = FALSE;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
cElement.SetElement(sExpress.Mid(iStart, i-iStart), TRUE);
|
|
lstElement.AddTail(cElement);
|
|
|
|
continue;
|
|
}
|
|
|
|
// 判断是否是括号
|
|
if (ch == _T('(') || ch == _T(')'))
|
|
{
|
|
cElement.SetElement(ch, FALSE);
|
|
lstElement.AddTail(cElement);
|
|
|
|
continue;
|
|
}
|
|
|
|
// 判断是否是符号
|
|
if (_istprint(ch) && !_istalnum(ch))
|
|
{
|
|
for (; i < iLen; i++)
|
|
{
|
|
ch = sExpress[i];
|
|
|
|
if (_istprint(ch) && !_istalnum(ch) && ch != _T(' ') && ch != _T('.') && ch != _T('(') && ch != _T(')'))
|
|
continue;
|
|
|
|
break;
|
|
}
|
|
|
|
cElement.SetElement(sExpress.Mid(iStart, i-iStart), FALSE);
|
|
lstElement.AddTail(cElement);
|
|
|
|
continue;
|
|
}
|
|
|
|
// 判断是否为汉字
|
|
if (!_istprint(ch) && i < iLen)
|
|
i++;
|
|
// 判断是否是字母字串
|
|
for (; i < iLen; i++)
|
|
{
|
|
ch = sExpress[i];
|
|
|
|
if (_istalnum(ch) || ch == _T('_'))
|
|
continue;
|
|
|
|
if (!_istprint(ch) && i+1 < iLen)
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
sVariable = sExpress.Mid(iStart, i-iStart);
|
|
if (sVariable.CompareNoCase(_T("ELSEIF")) == 0)
|
|
{
|
|
cElement.SetElement(_T("ELSE"), FALSE);
|
|
lstElement.AddTail(cElement);
|
|
sVariable = _T("IF");
|
|
}
|
|
cElement.SetElement(sVariable, FALSE);
|
|
lstElement.AddTail(cElement);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// 计算元素列表
|
|
BOOL KTExpressCalc::OnCalcElementList(CListElement& lstElement, double& dResult)
|
|
{
|
|
CListElement lstStack;
|
|
double dValue1, dValue2;
|
|
CElement cElement, cEleVar, cEleOpe;
|
|
while (!lstElement.IsEmpty())
|
|
{
|
|
cElement = lstElement.RemoveHead();
|
|
|
|
// 操作符
|
|
if (cElement.m_eEleType == KTExpressCalc::eEleOperate)
|
|
{
|
|
switch (cElement.m_cOperate.m_eOpeType)
|
|
{
|
|
case KTExpressCalc::eOpeLeftPthis: // 左括号 (...
|
|
// 压栈
|
|
lstStack.AddTail(cElement);
|
|
continue;
|
|
case KTExpressCalc::eOpeRightPthis: // 右括号 )
|
|
// 取出操作数
|
|
if (!OnPopTailVariable(lstStack, cEleVar))
|
|
return FALSE;
|
|
// 取出操作符
|
|
if (!OnPopTailOperator(lstStack, cEleOpe))
|
|
return FALSE;
|
|
// 如果不是左括号
|
|
while (cEleOpe.m_cOperate.m_eOpeType != KTExpressCalc::eOpeLeftPthis)
|
|
{
|
|
// 取出变量值
|
|
if (!OnGetElementValue(cEleVar, dValue2))
|
|
return FALSE;
|
|
// 是否是单目运算
|
|
switch (cEleOpe.m_cOperate.m_iEleNum)
|
|
{
|
|
case 1:
|
|
// 计算
|
|
dValue2 = ((lpfnCalcFun1)(cEleOpe.m_cOperate.m_pfnCalc))(dValue2);
|
|
if (!_finite(dValue2))
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eOutOfBound;
|
|
dValue2 = 0.0;
|
|
return FALSE;
|
|
}
|
|
break;
|
|
case 2:
|
|
// 取出操作数
|
|
if (!OnPopTailVariable(lstStack, cEleVar))
|
|
{
|
|
if (cEleOpe.m_cOperate.m_eOpeType == KTExpressCalc::eOpeAdd
|
|
|| cEleOpe.m_cOperate.m_eOpeType == KTExpressCalc::eOpeSubtract)
|
|
{
|
|
cEleVar.Clear();
|
|
cEleVar.m_eEleType = KTExpressCalc::eEleConstant;
|
|
cEleVar.m_dValue = 0.0;
|
|
m_eErrorCode = KTExpressCalc::eOk;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
// 取出变量值
|
|
if (!OnGetElementValue(cEleVar, dValue1))
|
|
return FALSE;
|
|
// 计算
|
|
dValue2 = ((lpfnCalcFun2)(cEleOpe.m_cOperate.m_pfnCalc))(dValue1, dValue2);
|
|
if (!_finite(dValue2))
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eOutOfBound;
|
|
dValue2 = 0.0;
|
|
return FALSE;
|
|
}
|
|
break;
|
|
default:
|
|
m_eErrorCode = KTExpressCalc::eMissOperator;
|
|
return FALSE;
|
|
}
|
|
// 构造操作数
|
|
cEleVar.Clear();
|
|
cEleVar.m_eEleType = KTExpressCalc::eEleConstant;
|
|
cEleVar.m_dValue = dValue2;
|
|
|
|
// 取出操作符
|
|
if (!OnPopTailOperator(lstStack, cEleOpe))
|
|
return FALSE;
|
|
}
|
|
// 操作数压栈
|
|
lstElement.AddHead(cEleVar);
|
|
// 栈为空
|
|
if (lstStack.IsEmpty())
|
|
continue;
|
|
// 取出操作符
|
|
if (!OnPopTailOperator(lstStack, cElement))
|
|
return FALSE;
|
|
// (, if
|
|
if (cElement.m_cOperate.m_eOpeType == KTExpressCalc::eOpeLeftPthis
|
|
|| cElement.m_cOperate.m_eOpeType == KTExpressCalc::eOpeIf)
|
|
{
|
|
// 压回栈
|
|
lstStack.AddTail(cElement);
|
|
continue;
|
|
}
|
|
break;
|
|
case KTExpressCalc::eOpeIf: // if...
|
|
// 压栈
|
|
lstStack.AddTail(cElement);
|
|
continue;
|
|
case KTExpressCalc::eOpeThen: // then...
|
|
// 取出操作数
|
|
if (!OnPopTailVariable(lstStack, cEleVar))
|
|
return FALSE;
|
|
// 取出操作符
|
|
if (!OnPopTailOperator(lstStack, cEleOpe))
|
|
return FALSE;
|
|
// 如果不是if，则必定是单目运算
|
|
while (cEleOpe.m_cOperate.m_eOpeType != KTExpressCalc::eOpeIf)
|
|
{
|
|
// 取出变量值
|
|
if (!OnGetElementValue(cEleVar, dValue2))
|
|
return FALSE;
|
|
// 是否是单目运算
|
|
switch (cEleOpe.m_cOperate.m_iEleNum)
|
|
{
|
|
case 1:
|
|
// 计算
|
|
dValue2 = ((lpfnCalcFun1)(cEleOpe.m_cOperate.m_pfnCalc))(dValue2);
|
|
if (!_finite(dValue2))
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eOutOfBound;
|
|
dValue2 = 0.0;
|
|
return FALSE;
|
|
}
|
|
break;
|
|
case 2:
|
|
// 取出操作数
|
|
if (!OnPopTailVariable(lstStack, cEleVar))
|
|
{
|
|
if (cEleOpe.m_cOperate.m_eOpeType == KTExpressCalc::eOpeAdd
|
|
|| cEleOpe.m_cOperate.m_eOpeType == KTExpressCalc::eOpeSubtract)
|
|
{
|
|
cEleVar.Clear();
|
|
cEleVar.m_eEleType = KTExpressCalc::eEleConstant;
|
|
cEleVar.m_dValue = 0.0;
|
|
m_eErrorCode = KTExpressCalc::eOk;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
// 取出变量值
|
|
if (!OnGetElementValue(cEleVar, dValue1))
|
|
return FALSE;
|
|
// 计算
|
|
dValue2 = ((lpfnCalcFun2)(cEleOpe.m_cOperate.m_pfnCalc))(0.0, dValue2);
|
|
if (!_finite(dValue2))
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eOutOfBound;
|
|
dValue2 = 0.0;
|
|
return FALSE;
|
|
}
|
|
break;
|
|
default:
|
|
m_eErrorCode = KTExpressCalc::eMissOperator;
|
|
return FALSE;
|
|
}
|
|
// 构造操作数
|
|
cEleVar.Clear();
|
|
cEleVar.m_eEleType = KTExpressCalc::eEleConstant;
|
|
cEleVar.m_dValue = dValue2;
|
|
// 取出操作符
|
|
if (!OnPopTailOperator(lstStack, cEleOpe))
|
|
return FALSE;
|
|
}
|
|
// 分支判断，去除不执行的分支
|
|
if (!OnGetElementValue(cEleVar, dValue1) || !OnCutOneOfIfThenElse(lstElement, fabs(dValue1) < EPS))
|
|
return FALSE;
|
|
// 栈为空
|
|
if (lstStack.IsEmpty())
|
|
continue;
|
|
// 取出操作符
|
|
if (!OnPopTailOperator(lstStack, cElement))
|
|
return FALSE;
|
|
// (, if
|
|
if (cElement.m_cOperate.m_eOpeType == KTExpressCalc::eOpeLeftPthis
|
|
|| cElement.m_cOperate.m_eOpeType == KTExpressCalc::eOpeIf)
|
|
{
|
|
// 压回栈
|
|
lstStack.AddTail(cElement);
|
|
continue;
|
|
}
|
|
break;
|
|
case KTExpressCalc::eOpeElse: // else...
|
|
m_eErrorCode = KTExpressCalc::eMissThen;
|
|
return FALSE;
|
|
}
|
|
|
|
cEleOpe = cElement;
|
|
while (!lstElement.IsEmpty())
|
|
{
|
|
// 将后面运算符比当前优先级还高的运算符压栈
|
|
if (OnNextPriTypeIsHigherThis(lstElement, cEleOpe))
|
|
{
|
|
lstStack.AddTail(cEleOpe);
|
|
break;
|
|
}
|
|
|
|
// 其他操作符运算，碰到( if 即结束
|
|
switch (cEleOpe.m_cOperate.m_iEleNum)
|
|
{
|
|
case -1:
|
|
// 取出操作数
|
|
if (!OnPopTailVariable(lstStack, cEleVar))
|
|
return FALSE;
|
|
// 取出变量值
|
|
if (!OnGetElementValue(cEleVar, dValue2))
|
|
return FALSE;
|
|
// 计算
|
|
dValue2 = ((lpfnCalcFun1)(cEleOpe.m_cOperate.m_pfnCalc))(dValue2);
|
|
if (!_finite(dValue2))
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eOutOfBound;
|
|
dValue2 = 0.0;
|
|
return FALSE;
|
|
}
|
|
break;
|
|
case 1:
|
|
// 取出操作数
|
|
if (!OnPopHeadVariable(lstElement, cEleVar))
|
|
return FALSE;
|
|
// 取出变量值
|
|
if (!OnGetElementValue(cEleVar, dValue2))
|
|
return FALSE;
|
|
// 计算
|
|
dValue2 = ((lpfnCalcFun1)(cEleOpe.m_cOperate.m_pfnCalc))(dValue2);
|
|
if (!_finite(dValue2))
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eOutOfBound;
|
|
dValue2 = 0.0;
|
|
return FALSE;
|
|
}
|
|
break;
|
|
case 2:
|
|
// 取出第2个操作数
|
|
if (!OnPopHeadVariable(lstElement, cEleVar))
|
|
return FALSE;
|
|
// 取出变量值
|
|
if (!OnGetElementValue(cEleVar, dValue2))
|
|
return FALSE;
|
|
// 取出第1个操作数
|
|
if (!OnPopTailVariable(lstStack, cEleVar))
|
|
{
|
|
if (cEleOpe.m_cOperate.m_eOpeType == KTExpressCalc::eOpeAdd
|
|
|| cEleOpe.m_cOperate.m_eOpeType == KTExpressCalc::eOpeSubtract)
|
|
{
|
|
cEleVar.Clear();
|
|
cEleVar.m_eEleType = KTExpressCalc::eEleConstant;
|
|
cEleVar.m_dValue = 0.0;
|
|
m_eErrorCode = KTExpressCalc::eOk;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
// 取出变量值
|
|
if (!OnGetElementValue(cEleVar, dValue1))
|
|
return FALSE;
|
|
// 计算
|
|
dValue2 = ((lpfnCalcFun2)(cEleOpe.m_cOperate.m_pfnCalc))(dValue1, dValue2);
|
|
if (!_finite(dValue2))
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eOutOfBound;
|
|
dValue2 = 0.0;
|
|
return FALSE;
|
|
}
|
|
break;
|
|
default:
|
|
m_eErrorCode = KTExpressCalc::eInvalidOperator;
|
|
return FALSE;
|
|
}
|
|
|
|
// 压回栈中
|
|
cElement.Clear();
|
|
cElement.m_eEleType = KTExpressCalc::eEleConstant;
|
|
cElement.m_dValue = dValue2;
|
|
lstElement.AddHead(cElement);
|
|
|
|
if (lstStack.IsEmpty())
|
|
break;
|
|
|
|
// 取出栈中元素
|
|
cElement = lstStack.GetTail();
|
|
|
|
// 是否是操作符
|
|
if (cElement.m_eEleType != KTExpressCalc::eEleOperate)
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eMissOperator;
|
|
return FALSE;
|
|
}
|
|
|
|
// 如果是if和(
|
|
if (cElement.m_cOperate.m_eOpeType == KTExpressCalc::eOpeIf
|
|
|| cElement.m_cOperate.m_eOpeType == KTExpressCalc::eOpeLeftPthis)
|
|
break;
|
|
|
|
cEleOpe = lstStack.RemoveTail();
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// 判断是否有操作符
|
|
if (!lstStack.IsEmpty() && lstStack.GetTail().m_eEleType != KTExpressCalc::eEleOperate)
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eMissOperator;
|
|
return FALSE;
|
|
}
|
|
|
|
lstStack.AddTail(cElement);
|
|
}
|
|
|
|
// 取出操作数
|
|
if (!OnPopTailVariable(lstStack, cEleVar))
|
|
return FALSE;
|
|
|
|
// 如果栈中有多项
|
|
while (!lstStack.IsEmpty())
|
|
{
|
|
// 取出操作符
|
|
if (!OnPopTailOperator(lstStack, cEleOpe))
|
|
return FALSE;
|
|
// 取出变量值
|
|
if (!OnGetElementValue(cEleVar, dValue2))
|
|
return FALSE;
|
|
// 是否是单目运算
|
|
switch (cEleOpe.m_cOperate.m_iEleNum)
|
|
{
|
|
case 1:
|
|
// 计算
|
|
dValue2 = ((lpfnCalcFun1)(cEleOpe.m_cOperate.m_pfnCalc))(dValue2);
|
|
if (!_finite(dValue2))
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eOutOfBound;
|
|
dValue2 = 0.0;
|
|
return FALSE;
|
|
}
|
|
break;
|
|
case 2:
|
|
// 取出操作数
|
|
if (!OnPopTailVariable(lstStack, cEleVar))
|
|
{
|
|
if (cEleOpe.m_cOperate.m_eOpeType == KTExpressCalc::eOpeAdd
|
|
|| cEleOpe.m_cOperate.m_eOpeType == KTExpressCalc::eOpeSubtract)
|
|
{
|
|
cEleVar.Clear();
|
|
cEleVar.m_eEleType = KTExpressCalc::eEleConstant;
|
|
cEleVar.m_dValue = 0.0;
|
|
m_eErrorCode = KTExpressCalc::eOk;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
// 取出变量值
|
|
if (!OnGetElementValue(cEleVar, dValue1))
|
|
return FALSE;
|
|
// 计算
|
|
dValue2 = ((lpfnCalcFun2)(cEleOpe.m_cOperate.m_pfnCalc))(dValue1, dValue2);
|
|
if (!_finite(dValue2))
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eOutOfBound;
|
|
dValue2 = 0.0;
|
|
return FALSE;
|
|
}
|
|
break;
|
|
default:
|
|
m_eErrorCode = KTExpressCalc::eMissOperator;
|
|
return FALSE;
|
|
}
|
|
// 构造操作数
|
|
cEleVar.Clear();
|
|
cEleVar.m_eEleType = KTExpressCalc::eEleConstant;
|
|
cEleVar.m_dValue = dValue2;
|
|
}
|
|
|
|
// 取出变量值
|
|
if (!OnGetElementValue(cEleVar, dResult))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// 弹出尾部操作符
|
|
BOOL KTExpressCalc::OnPopTailOperator(CListElement& lstElement, CElement& cEleOpe)
|
|
{
|
|
// 是否为空
|
|
if (lstElement.IsEmpty())
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eMissOperator;
|
|
return FALSE;
|
|
}
|
|
|
|
// 弹出操作符
|
|
cEleOpe = lstElement.RemoveTail();
|
|
|
|
// 判断操作符是否合法
|
|
if (cEleOpe.m_eEleType == KTExpressCalc::eEleOperate)
|
|
return TRUE;
|
|
|
|
// 压回栈
|
|
lstElement.AddTail(cEleOpe);
|
|
|
|
m_eErrorCode = KTExpressCalc::eMissOperator;
|
|
return FALSE;
|
|
}
|
|
|
|
// 弹出头部操作数
|
|
BOOL KTExpressCalc::OnPopHeadVariable(CListElement& lstElement, CElement& cEleVar)
|
|
{
|
|
// 是否为空
|
|
if (lstElement.IsEmpty())
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eMissVariable;
|
|
return FALSE;
|
|
}
|
|
|
|
// 弹出操作数
|
|
cEleVar = lstElement.RemoveHead();
|
|
|
|
// 判断操作数是否合法
|
|
if (cEleVar.m_eEleType == KTExpressCalc::eEleConstant
|
|
|| cEleVar.m_eEleType == KTExpressCalc::eEleVariable)
|
|
return TRUE;
|
|
|
|
// 压回栈
|
|
lstElement.AddHead(cEleVar);
|
|
|
|
m_eErrorCode = KTExpressCalc::eMissVariable;
|
|
return FALSE;
|
|
}
|
|
|
|
// 弹出尾部操作数
|
|
BOOL KTExpressCalc::OnPopTailVariable(CListElement& lstElement, CElement& cEleVar)
|
|
{
|
|
// 是否为空
|
|
if (lstElement.IsEmpty())
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eMissVariable;
|
|
return FALSE;
|
|
}
|
|
|
|
// 弹出操作数
|
|
cEleVar = lstElement.RemoveTail();
|
|
|
|
// 判断操作数是否合法
|
|
if (cEleVar.m_eEleType == KTExpressCalc::eEleConstant
|
|
|| cEleVar.m_eEleType == KTExpressCalc::eEleVariable)
|
|
return TRUE;
|
|
|
|
// 压回栈
|
|
lstElement.AddTail(cEleVar);
|
|
|
|
m_eErrorCode = KTExpressCalc::eMissVariable;
|
|
return FALSE;
|
|
}
|
|
|
|
// 取得元素值
|
|
BOOL KTExpressCalc::OnGetElementValue(CElement& cEleVar, double& dValue)
|
|
{
|
|
if (cEleVar.m_eEleType == KTExpressCalc::eEleConstant)
|
|
{
|
|
dValue = cEleVar.m_dValue;
|
|
return TRUE;
|
|
}
|
|
|
|
if (cEleVar.m_eEleType == KTExpressCalc::eEleVariable && OnGetVariable(cEleVar.m_pszVariable, dValue))
|
|
return TRUE;
|
|
|
|
m_eErrorCode = KTExpressCalc::eInvalidVariable;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// 根据条件去除if-then-else分支中的一条
|
|
BOOL KTExpressCalc::OnCutOneOfIfThenElse(CListElement& lstElement, BOOL bElse)
|
|
{
|
|
int iStack = 1;
|
|
CElement cElement;
|
|
POSITION posBak = NULL;
|
|
POSITION pos = lstElement.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
posBak = pos;
|
|
cElement = lstElement.GetNext(pos);
|
|
|
|
if (cElement.m_eEleType == KTExpressCalc::eEleOperate)
|
|
{
|
|
// 嵌套if
|
|
if (cElement.m_cOperate.m_eOpeType == KTExpressCalc::eOpeIf)
|
|
iStack++;
|
|
else if (cElement.m_cOperate.m_eOpeType == KTExpressCalc::eOpeElse)
|
|
{
|
|
iStack--;
|
|
if (iStack == 0)
|
|
pos = NULL;
|
|
}
|
|
}
|
|
|
|
if (bElse)
|
|
lstElement.RemoveAt(posBak);
|
|
}
|
|
|
|
if (iStack > 0)
|
|
{
|
|
m_eErrorCode = KTExpressCalc::eMissElse;
|
|
return FALSE;
|
|
}
|
|
|
|
if (bElse)
|
|
return TRUE;
|
|
|
|
iStack = 1;
|
|
pos = posBak;
|
|
while (pos != NULL)
|
|
{
|
|
posBak = pos;
|
|
cElement = lstElement.GetNext(pos);
|
|
|
|
if (cElement.m_eEleType == KTExpressCalc::eEleOperate)
|
|
{
|
|
// 嵌套(
|
|
if (cElement.m_cOperate.m_eOpeType == KTExpressCalc::eOpeLeftPthis)
|
|
iStack++;
|
|
else if (cElement.m_cOperate.m_eOpeType == KTExpressCalc::eOpeRightPthis)
|
|
{
|
|
iStack--;
|
|
if (iStack == 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
lstElement.RemoveAt(posBak);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// 判断是否后面的运算符比给定的优先级高
|
|
BOOL KTExpressCalc::OnNextPriTypeIsHigherThis(CListElement& lstElement, CElement& cEleOpe)
|
|
{
|
|
CElement cElement;
|
|
POSITION pos = lstElement.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
cElement = lstElement.GetNext(pos);
|
|
if (cElement.m_eEleType == KTExpressCalc::eEleOperate)
|
|
{
|
|
if (cElement.m_cOperate.m_ePriType > cEleOpe.m_cOperate.m_ePriType)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// 设置变量数据
|
|
void KTExpressCalc::SetVariableData(LPCTSTR pszVariable, double dValue)
|
|
{
|
|
ASSERT(pszVariable != NULL && _tcslen(pszVariable) > 0);
|
|
m_mapVariable.SetAt(pszVariable, dValue);
|
|
}
|
|
|
|
// 取得变量数据
|
|
BOOL KTExpressCalc::GetVariableData(LPCTSTR pszVariable, double& dValue) const
|
|
{
|
|
ASSERT(pszVariable != NULL && _tcslen(pszVariable) > 0);
|
|
return m_mapVariable.Lookup(pszVariable, dValue);
|
|
}
|
|
|
|
// 设置变量数据，当传入为NULL时，清除变量数据
|
|
void KTExpressCalc::SetVariableData(const CMapStringToDouble* pMapVariable)
|
|
{
|
|
if (pMapVariable == NULL)
|
|
{
|
|
m_mapVariable.RemoveAll();
|
|
}
|
|
else
|
|
{
|
|
double dValue;
|
|
CString sVariable;
|
|
POSITION pos = pMapVariable->GetStartPosition();
|
|
while (pos != NULL)
|
|
{
|
|
pMapVariable->GetNextAssoc(pos, sVariable, dValue);
|
|
m_mapVariable.SetAt(sVariable, dValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 设置取变量值回调函数，当传入为NULL时，清除回调函数
|
|
void KTExpressCalc::SetVariableProc(lpfnGetVariableProc pfnProc, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
m_pfnGetVariable = pfnProc;
|
|
m_wParam = wParam;
|
|
m_lParam = lParam;
|
|
}
|
|
|
|
// 取得变量值
|
|
BOOL KTExpressCalc::OnGetVariable(LPCTSTR pszVariable, double& dValue)
|
|
{
|
|
if (m_mapVariable.Lookup(pszVariable, dValue))
|
|
return TRUE;
|
|
|
|
if (m_pfnGetVariable != NULL && m_pfnGetVariable(pszVariable, dValue, m_wParam, m_lParam))
|
|
return TRUE;
|
|
|
|
m_eErrorCode = KTExpressCalc::eVarialbeNotFind;
|
|
return FALSE;
|
|
}
|
|
|
|
// 取得错误代码
|
|
KTExpressCalc::EErrorCode KTExpressCalc::GetErrorCode()
|
|
{
|
|
return m_eErrorCode;
|
|
}
|