Esempio n. 1
0
        public string VisitLambdaPredicateNode(ILambdaPredicateASTNode lambdaPredicate)
        {
            string firstOperandStr = (lambdaPredicate.FirstOperand as IASTNode).Accept(this);

            switch (lambdaPredicate.LOPType)
            {
            case E_LOGIC_OP_TYPE.LOT_GT:
                return(string.Format("({0} {1})", ">", firstOperandStr));

            case E_LOGIC_OP_TYPE.LOT_GE:
                return(string.Format("({0} {1})", ">=", firstOperandStr));

            case E_LOGIC_OP_TYPE.LOT_LT:
                return(string.Format("({0} {1})", "<", firstOperandStr));

            case E_LOGIC_OP_TYPE.LOT_LE:
                return(string.Format("({0} {1})", "<=", firstOperandStr));

            case E_LOGIC_OP_TYPE.LOT_EQ:
                return(string.Format("({0} {1})", "==", firstOperandStr));

            case E_LOGIC_OP_TYPE.LOT_NEQ:
                return(string.Format("({0} {1})", "!=", firstOperandStr));

            case E_LOGIC_OP_TYPE.LOT_MOD:
                return(string.Format("(% {0} == {1})", firstOperandStr, (lambdaPredicate.SecondOperand as IASTNode).Accept(this)));
            }

            return(string.Empty);
        }
Esempio n. 2
0
        public Object VisitLambdaPredicateNode(ILambdaPredicateASTNode lambdaPredicate)
        {
            if (lambdaPredicate == null)
            {
                throw new ArgumentNullException("lambdaPredicate", "The argument cannot equal to null");
            }

            ParameterExpression x = Expression.Parameter(typeof(int), "x");

            Expression value = Expression.Constant(lambdaPredicate.FirstOperand.Value[0]);

            Expression lambdaBody = Expression.Empty();

            switch (lambdaPredicate.LOPType)
            {
            case E_LOGIC_OP_TYPE.LOT_EQ:
                lambdaBody = Expression.Equal(value, x);
                break;

            case E_LOGIC_OP_TYPE.LOT_NEQ:
                lambdaBody = Expression.NotEqual(value, x);
                break;

            case E_LOGIC_OP_TYPE.LOT_LT:
                lambdaBody = Expression.LessThan(x, value);
                break;

            case E_LOGIC_OP_TYPE.LOT_LE:
                lambdaBody = Expression.LessThanOrEqual(x, value);
                break;

            case E_LOGIC_OP_TYPE.LOT_GT:
                lambdaBody = Expression.GreaterThan(x, value);
                break;

            case E_LOGIC_OP_TYPE.LOT_GE:
                lambdaBody = Expression.GreaterThanOrEqual(x, value);
                break;

            case E_LOGIC_OP_TYPE.LOT_MOD:

                if ((mAttributes & E_INTERPRETER_ATTRIBUTES.IA_IS_SAFE_DIVISION_ENABLED) == E_INTERPRETER_ATTRIBUTES.IA_IS_SAFE_DIVISION_ENABLED)
                {
                    lambdaBody = Expression.Equal(_createSafeModuloOperator(x, value), Expression.Constant(lambdaPredicate.SecondOperand.Value[0]));
                }
                else
                {
                    lambdaBody = Expression.Equal(Expression.Modulo(x, value), Expression.Constant(lambdaPredicate.SecondOperand.Value[0]));
                }

                break;
            }

            return(Expression.Lambda(lambdaBody, x).Compile());
        }
Esempio n. 3
0
        public CIfThenElseASTNode(IASTNode var, ILambdaPredicateASTNode pred,
                                  IASTNode thenBranch, IASTNode elseBranch) :
            base(E_NODE_TYPE.NT_IF_THEN_ELSE)
        {
            IASTNode predicateNode = pred as IASTNode;

            var.Parent           = this;
            predicateNode.Parent = this;
            thenBranch.Parent    = this;
            elseBranch.Parent    = this;

            var.NodeId           = 0;
            predicateNode.NodeId = 1;
            thenBranch.NodeId    = 2;
            elseBranch.NodeId    = 3;

            mChildren.Add(var);
            mChildren.Add(predicateNode);
            mChildren.Add(thenBranch);
            mChildren.Add(elseBranch);
        }