コード例 #1
0
        /// <summary>
        /// Evaluates the specified expression.
        /// </summary>
        /// <param name="expression">The expression.</param>
        /// <returns>Result of the expression evaluated</returns>
        public ExpressionResult Evaluate(Expression expression)
        {
            values.Clear();
            result = new ExpressionResult();

            // Small optim, if LiteralExpression, we perform a direct eval.
            var literalExpression = expression as LiteralExpression;

            if (literalExpression != null)
            {
                Visit(literalExpression);
            }
            else
            {
                VisitDynamic(expression);
            }

            if (values.Count == 1)
            {
                result.Value = values.Pop();
            }
            else
            {
                result.Error("Cannot evaluate expression {0}", expression.Span, expression);
            }
            return(result);
        }
コード例 #2
0
        protected virtual void Visit(BinaryExpression binaryExpression)
        {
            Visit((Node)binaryExpression);

            var rightValue = values.Pop();
            var leftValue  = values.Pop();

            switch (binaryExpression.Operator)
            {
            case BinaryOperator.Plus:
                values.Push(leftValue + rightValue);
                break;

            case BinaryOperator.Minus:
                values.Push(leftValue - rightValue);
                break;

            case BinaryOperator.Multiply:
                values.Push(leftValue * rightValue);
                break;

            case BinaryOperator.Divide:
                values.Push(leftValue / rightValue);
                break;

            case BinaryOperator.Modulo:
                values.Push(leftValue % rightValue);
                break;

            case BinaryOperator.LeftShift:
                values.Push((int)leftValue << (int)rightValue);
                break;

            case BinaryOperator.RightShift:
                values.Push((int)leftValue >> (int)rightValue);
                break;

            case BinaryOperator.BitwiseOr:
                values.Push(((int)leftValue) | ((int)rightValue));
                break;

            case BinaryOperator.BitwiseAnd:
                values.Push(((int)leftValue) & ((int)rightValue));
                break;

            case BinaryOperator.BitwiseXor:
                values.Push(((int)leftValue) ^ ((int)rightValue));
                break;

            default:
                result.Error("Binary operator [{0}] is not supported", binaryExpression.Span, binaryExpression);
                values.Push(0);
                break;
            }
        }
コード例 #3
0
ファイル: ExpressionEvaluator.cs プロジェクト: vol16bit/xenko
        public override void DefaultVisit(Node node)
        {
            var expression = node as Expression;

            if (expression != null)
            {
                if (!(expression is BinaryExpression || expression is MethodInvocationExpression || expression is VariableReferenceExpression || expression is LiteralExpression || expression is ParenthesizedExpression || expression is UnaryExpression))
                {
                    result.Error("Expression evaluation [{0}] is not supported", expression.Span, expression);
                }
            }
        }
コード例 #4
0
        /// <summary>
        /// Evaluates the specified expression.
        /// </summary>
        /// <param name="expression">The expression.</param>
        /// <returns>Result of the expression evaluated</returns>
        public ExpressionResult Evaluate(Expression expression)
        {
            values.Clear();
            result = new ExpressionResult();

            // Small optim, if LiteralExpression, we perform a direct eval.
            var literalExpression = expression as LiteralExpression;
            if (literalExpression != null)
            {
                Visit(literalExpression);
            }
            else
            {
                VisitDynamic(expression);
            }

            if (values.Count == 1)
                result.Value = values.Pop();
            else
            {
                result.Error("Cannot evaluate expression {0}", expression.Span, expression);
            }
            return result;
        }
コード例 #5
0
 protected virtual void Visit(Expression expression)
 {
     result.Error("Expression evaluation [{0}] is not supported", expression.Span, expression);
 }