コード例 #1
0
        public ImmutableHashSet <object> VisitZenIntegerBinopExpr <T>(ZenIntegerBinopExpr <T> expression, Unit parameter)
        {
            return(LookupOrCompute(expression, () =>
            {
                var x = expression.Expr1.Accept(this, parameter);
                var y = expression.Expr2.Accept(this, parameter);

                switch (expression.Operation)
                {
                case Op.Addition:
                case Op.Multiplication:
                case Op.Subtraction:
                case Op.BitwiseAnd:
                case Op.BitwiseXor:
                    this.Combine(x, y);
                    return x.Union(y);

                default:
                    return x.Union(y);
                }
            }));
        }
コード例 #2
0
        public Expression VisitZenIntegerBinopExpr <T>(ZenIntegerBinopExpr <T> expression, ExpressionConverterEnvironment parameter)
        {
            return(LookupOrCompute(expression, () =>
            {
                switch (expression.Operation)
                {
                case Op.BitwiseAnd:
                    return BitwiseAnd <T>(
                        expression.Expr1.Accept(this, parameter),
                        expression.Expr2.Accept(this, parameter));

                case Op.BitwiseOr:
                    return BitwiseOr <T>(
                        expression.Expr1.Accept(this, parameter),
                        expression.Expr2.Accept(this, parameter));

                case Op.BitwiseXor:
                    return BitwiseXor <T>(
                        expression.Expr1.Accept(this, parameter),
                        expression.Expr2.Accept(this, parameter));

                case Op.Addition:
                    return Add <T>(
                        expression.Expr1.Accept(this, parameter),
                        expression.Expr2.Accept(this, parameter));

                case Op.Subtraction:
                    return Subtract <T>(
                        expression.Expr1.Accept(this, parameter),
                        expression.Expr2.Accept(this, parameter));

                default:
                    return Expression.Multiply(
                        expression.Expr1.Accept(this, parameter),
                        expression.Expr2.Accept(this, parameter));
                }
            }));
        }
コード例 #3
0
        public SymbolicValue <TModel, TVar, TBool, TInt, TString> VisitZenIntegerBinopExpr <T1>(ZenIntegerBinopExpr <T1> expression, SymbolicEvaluationEnvironment <TModel, TVar, TBool, TInt, TString> parameter)
        {
            return(LookupOrCompute(expression, () =>
            {
                var v1 = (SymbolicInteger <TModel, TVar, TBool, TInt, TString>)expression.Expr1.Accept(this, parameter);
                var v2 = (SymbolicInteger <TModel, TVar, TBool, TInt, TString>)expression.Expr2.Accept(this, parameter);

                switch (expression.Operation)
                {
                case Op.BitwiseAnd:
                    return new SymbolicInteger <TModel, TVar, TBool, TInt, TString>(this.Solver, this.Solver.BitwiseAnd(v1.Value, v2.Value));

                case Op.BitwiseOr:
                    return new SymbolicInteger <TModel, TVar, TBool, TInt, TString>(this.Solver, this.Solver.BitwiseOr(v1.Value, v2.Value));

                case Op.BitwiseXor:
                    return new SymbolicInteger <TModel, TVar, TBool, TInt, TString>(this.Solver, this.Solver.BitwiseXor(v1.Value, v2.Value));

                case Op.Addition:
                    return new SymbolicInteger <TModel, TVar, TBool, TInt, TString>(this.Solver, this.Solver.Add(v1.Value, v2.Value));

                case Op.Subtraction:
                    return new SymbolicInteger <TModel, TVar, TBool, TInt, TString>(this.Solver, this.Solver.Subtract(v1.Value, v2.Value));

                default:
                    return new SymbolicInteger <TModel, TVar, TBool, TInt, TString>(this.Solver, this.Solver.Multiply(v1.Value, v2.Value));
                }
            }));
        }