⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 evaluator.cs

📁 字符串表达式的计算。本程序是一个Window Forms应用程序
💻 CS
📖 第 1 页 / 共 5 页
字号:
            tokenEvalTime = evalTime.Elapsed.TotalMilliseconds;
            token.LastEvaluationTime = tokenEvalTime; // set this evaluation time in the token object.
            return true;
            */
            #endregion
        }

        #endregion

        #region Private Methods

        private bool EvaluateTokens(Parser.TokenItem LeftOperand, Parser.TokenItem RightOperand, Parser.TokenItem Operator, out Parser.TokenItem Result, out string ErrorMsg)
        {
            // intitialize the outgoing variables
            Result = null;
            ErrorMsg = "";

            // local variables
            double dResult = 0;
            bool boolResult = false;

            // validate the parameters
            if (LeftOperand == null)
            {
                ErrorMsg = "Failed to evaluate the operator: The left token is null.";
                return false;
            }
            
            if (RightOperand == null)
            {
                ErrorMsg = "Failed to evaluate the operator: The right token is null.";
                return false;
            }
            
            if (Operator == null)
            {
                ErrorMsg = "Failed to evaluate the operator: The operator token is null.";
                return false;
            }


            switch (Operator.TokenName.Trim().ToLower())
            {
                case "^":
                    #region Exponents

                    // Exponents require that both operands can be converted to doubles
                    try
                    {
                        if ((Support.DataTypeCheck.IsDouble(LeftOperand.TokenName) == true) && (Support.DataTypeCheck.IsDouble(RightOperand.TokenName) == true))
                        {
                            dResult = Math.Pow(LeftOperand.TokenName_Double, RightOperand.TokenName_Double);
                            Result = new Parser.TokenItem(dResult.ToString(), Parser.TokenType.Token_Operand, EvaluationEngine.Parser.TokenDataType.Token_DataType_Double, LeftOperand.InOperandFunction);
                        }
                        else
                        {
                            ErrorMsg = "Syntax Error: Expecting numeric values for exponents.";
                            return false;
                        }                        
                    }
                    catch (Exception err)
                    {
                        ErrorMsg = "Failed to evaluate the Exponent operator: " + err.Message;
                        return false;
                    }
                    break;
                    #endregion

                case "*":
                    #region Multiplication

                    //  multiplication expects that the operands can be converted to doubles
                    try
                    {
                        if ((Support.DataTypeCheck.IsDouble(LeftOperand.TokenName) == true) && (Support.DataTypeCheck.IsDouble(RightOperand.TokenName) == true))
                        {
                            dResult = LeftOperand.TokenName_Double * RightOperand.TokenName_Double;
                            Result = new Parser.TokenItem(dResult.ToString(), Parser.TokenType.Token_Operand, EvaluationEngine.Parser.TokenDataType.Token_DataType_Double, LeftOperand.InOperandFunction);
                        }
                        else
                        {
                            ErrorMsg = "Syntax Error: Expecting numeric values to multiply.";
                            return false;
                        }
                    }
                    catch (Exception err)
                    {
                        ErrorMsg = "Failed to evaluate the Multiplication operator: " + err.Message;
                        return false;
                    }
                    break;
                    #endregion

                case "/":
                    #region Division

                    // divison requires that both operators can be converted to doubles and the denominator is not 0

                    try
                    {
                        if ((Support.DataTypeCheck.IsDouble(LeftOperand.TokenName) == true) && (Support.DataTypeCheck.IsDouble(RightOperand.TokenName) == true))
                        {
                            double denominator = RightOperand.TokenName_Double;

                            if (denominator != 0)
                            {
                                dResult = LeftOperand.TokenName_Double / denominator;
                                Result = new Parser.TokenItem(dResult.ToString(), Parser.TokenType.Token_Operand, EvaluationEngine.Parser.TokenDataType.Token_DataType_Double, LeftOperand.InOperandFunction);
                            }
                            else
                            {
                                ErrorMsg = "Syntax Error: Division by zero.";
                                return false;
                            }
                        }
                        else
                        {
                            ErrorMsg = "Syntax Error: Expecting numeric values to divide.";
                            return false;
                        }
                    }
                    catch (Exception err)
                    {
                        ErrorMsg = "Failed to evaluate the Division operator: " + err.Message;
                        return false;
                    }
                    break;
                    #endregion

                case "%":
                    #region Modulus
                    try
                    {
                        // modulus expects that both operators are numeric and the right operand is not zero
                        if ((Support.DataTypeCheck.IsDouble(LeftOperand.TokenName) == true) && (Support.DataTypeCheck.IsDouble(RightOperand.TokenName) == true))
                        {
                            double denominator = RightOperand.TokenName_Double;

                            if (denominator != 0)
                            {

                                dResult = LeftOperand.TokenName_Double % RightOperand.TokenName_Double;
                                Result = new Parser.TokenItem(dResult.ToString(), Parser.TokenType.Token_Operand, EvaluationEngine.Parser.TokenDataType.Token_DataType_Double, LeftOperand.InOperandFunction);
                            }
                            else
                            {
                                ErrorMsg = "Syntax Error: Modulus by zero.";
                                return false;
                            }
                        }
                        else
                        {
                            ErrorMsg = "Syntax Error: Expecting numeric values to modulus.";
                            return false;
                        }
                    }
                    catch (Exception err)
                    {
                        ErrorMsg = "Failed to evaluate the Modulus operator: " + err.Message;
                        return false;
                    }
                    break;
                    #endregion

                case "+":
                    #region Addition

                    try
                    {
                        // addition only works on numeric operands
                        if ((Support.DataTypeCheck.IsDouble(LeftOperand.TokenName) == true) && (Support.DataTypeCheck.IsDouble(RightOperand.TokenName) == true))
                        {
                            dResult = LeftOperand.TokenName_Double + RightOperand.TokenName_Double;
                            Result = new Parser.TokenItem(dResult.ToString(), Parser.TokenType.Token_Operand, EvaluationEngine.Parser.TokenDataType.Token_DataType_Double, LeftOperand.InOperandFunction);
                        }
                        else
                        {
                            ErrorMsg = "Syntax Error: Expecting numeric values to add.";
                            return false;
                        }
                    }
                    catch (Exception err)
                    {
                        ErrorMsg = "Failed to evaluate the Addition operator: " + err.Message;
                        return false;
                    }

                    break;
                    #endregion

                case "-":
                    #region Subtraction
                    try
                    {
                        // subtraction only works on numeric operands
                        if ((Support.DataTypeCheck.IsDouble(LeftOperand.TokenName) == true) && (Support.DataTypeCheck.IsDouble(RightOperand.TokenName) == true))
                        {
                            dResult = LeftOperand.TokenName_Double - RightOperand.TokenName_Double;
                            Result = new Parser.TokenItem(dResult.ToString(), Parser.TokenType.Token_Operand, EvaluationEngine.Parser.TokenDataType.Token_DataType_Double, LeftOperand.InOperandFunction);
                        }
                        else
                        {
                            ErrorMsg = "Syntax Error: Expecting numeric values to subtract.";
                            return false;
                        }                        
                    }
                    catch (Exception err)
                    {
                        ErrorMsg = "Failed to evaluate the Subtraction operator: " + err.Message;
                        return false;
                    }
                    break;
                    #endregion

                case "<":
                    #region Less Than
                    if ((Support.DataTypeCheck.IsDouble(LeftOperand.TokenName) == true) && (Support.DataTypeCheck.IsDouble(RightOperand.TokenName) == true))
                    {
                        try
                        {
                            // do a numeric comparison
                            boolResult = (LeftOperand.TokenName_Double < RightOperand.TokenName_Double);
                            Result = new Parser.TokenItem(boolResult.ToString().ToLower(), Parser.TokenType.Token_Operand, EvaluationEngine.Parser.TokenDataType.Token_DataType_Boolean, LeftOperand.InOperandFunction);
                        }
                        catch (Exception err)
                        {
                            ErrorMsg = "Failed to evaluate the Less Than operator on double operands: " + err.Message;
                            return false;
                        }
                    }
                    else if ((Support.DataTypeCheck.IsDate(LeftOperand.TokenName) == true) && (Support.DataTypeCheck.IsDate(RightOperand.TokenName) == true))
                    {
                        try
                        {
                            // do a date comparison
                            TimeSpan ts = LeftOperand.TokenName_DateTime.Subtract(RightOperand.TokenName_DateTime);
                            boolResult = (ts.TotalDays < 0);
                            Result = new Parser.TokenItem(boolResult.ToString().ToLower(), Parser.TokenType.Token_Operand, EvaluationEngine.Parser.TokenDataType.Token_DataType_Boolean, LeftOperand.InOperandFunction);
                        }
                        catch (Exception err)
                        {
                            ErrorMsg = "Failed to evaluate the Less Than operator on date operands: " + err.Message;
                            return false;
                        }
                    }
                    else
                    {
                        try
                        {
                            // do a string comparison
                            string lText = Support.DataTypeCheck.RemoveTextQuotes(LeftOperand.TokenName);
                            string rText = Support.DataTypeCheck.RemoveTextQuotes(RightOperand.TokenName);

                            boolResult = (lText.CompareTo(rText) < 0);
                            Result = new Parser.TokenItem(boolResult.ToString().ToLower(), Parser.TokenType.Token_Operand, EvaluationEngine.Parser.TokenDataType.Token_DataType_Boolean, LeftOperand.InOperandFunction);
                        }
                        catch (Exception err)
                        {
                            ErrorMsg = "Failed to evaluate the Less Than operator on string operands: " + err.Message;
                            return false;
                        }
                    }
                   
                    break;
                    #endregion

                case "<=":
                    #region Less Than Equal To

                    if ((Support.DataTypeCheck.IsDouble(LeftOperand.TokenName) == true) && (Support.DataTypeCheck.IsDouble(RightOperand.TokenName) == true))
                    {
                        try
                        {
                            // do a numeric comparison
                            boolResult = (LeftOperand.TokenName_Double <= RightOperand.TokenName_Double);
                            Result = new Parser.TokenItem(boolResult.ToString().ToLower(), Parser.TokenType.Token_Operand, EvaluationEngine.Parser.TokenDataType.Token_DataType_Boolean, LeftOperand.InOperandFunction);
                        }
                        catch (Exception err)
                        {
                            ErrorMsg = "Failed to evaluate the Less Than or Equal to operator on double operands: " + err.Message;
                            return false;
                        }
                    }
                    else if ((Support.DataTypeCheck.IsDate(LeftOperand.TokenName) == true) && (Support.DataTypeCheck.IsDate(RightOperand.TokenName) == true))
                    {
                        try
                        {
                            // do a date comparison
                            TimeSpan ts = LeftOperand.TokenName_DateTime.Subtract(RightOperand.TokenName_DateTime);
                            boolResult = (ts.TotalDays <= 0);
                            Res

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -