Not() public static method

Creates a UnaryExpression that represents a bitwise complement operation.
/// is null. The unary not operator is not defined for .Type.
public static Not ( Expression expression ) : UnaryExpression
expression Expression An to set the property equal to.
return UnaryExpression
        protected override object VisitIf(If I)
        {
            string name = target.LabelName();

            LinqExprs.LabelTarget _else = LinqExpr.Label("if_" + name + "_else");
            LinqExprs.LabelTarget end   = LinqExpr.Label("if_" + name + "_end");

            // Check the condition, exit if necessary.
            target.Add(LinqExpr.IfThen(LinqExpr.Not(target.Compile(I.Condition)), LinqExpr.Goto(_else)));

            // Execute true code.
            target.PushScope();
            Visit(I.True);
            target.PopScope();
            target.Add(LinqExpr.Goto(end));

            // Execute false code.
            target.Add(LinqExpr.Label(_else));
            target.PushScope();
            Visit(I.False);
            target.PopScope();

            // Exit point.
            target.Add(LinqExpr.Label(end));
            return(null);
        }
Beispiel #2
0
        /// <summary>
        /// Generate a while loop with the given code generator functions.
        /// </summary>
        /// <param name="Condition"></param>
        /// <param name="Body"></param>
        public void While(
            LinqExpr Condition,
            Action <LinqExpr, LinqExpr> Body)
        {
            string name = LabelName();

            LinqExprs.LabelTarget begin = LinqExpr.Label("while_" + name + "_begin");
            LinqExprs.LabelTarget end   = LinqExpr.Label("while_" + name + "_end");

            PushScope();

            // Check the condition, exit if necessary.
            code.Add(LinqExpr.Label(begin));
            code.Add(LinqExpr.IfThen(LinqExpr.Not(Condition), LinqExpr.Goto(end)));

            // Generate the body code.
            Body(LinqExpr.Goto(end), LinqExpr.Goto(begin));

            // Loop.
            code.Add(LinqExpr.Goto(begin));

            // Exit label.
            code.Add(LinqExpr.Label(end));

            PopScope();
        }
        protected override object VisitWhile(While W)
        {
            string name = target.LabelName();

            LinqExprs.LabelTarget begin = LinqExpr.Label("while_" + name + "_begin");
            LinqExprs.LabelTarget end   = LinqExpr.Label("while_" + name + "_end");
            loops.Push(new Loop(LinqExpr.Goto(end), LinqExpr.Goto(begin)));

            target.PushScope();

            // Check the condition, exit if necessary.
            target.Add(LinqExpr.Label(begin));
            target.Add(LinqExpr.IfThen(LinqExpr.Not(target.Compile(W.Condition)), LinqExpr.Goto(end)));

            // Generate the body target.
            Visit(W.Body);

            // Loop.
            target.Add(LinqExpr.Goto(begin));

            // Exit label.
            target.Add(LinqExpr.Label(end));

            loops.Pop();
            target.PopScope();
            return(null);
        }
        public LambdaExpression CreateLambda(Type from, Type to)
        {
            var toParameters = to.GetTypeInfo().GenericTypeArguments;
            var tupa         = toParameters.Length;
            var input        = Ex.Parameter(from, "input");
            var converters   = toParameters.Select(p => Ref.GetLambda(typeof(string), p)).ToArray();
            var res          = toParameters.Select(p => Ex.Parameter(typeof(ConversionResult <>).MakeGenericType(p))).ToArray();
            var end          = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to), "end");
            var indexer      = typeof(string[]).GetTypeInfo().GetDeclaredProperty("Item");

            var split      = Ex.Parameter(typeof(string[]), "split");
            var conversion = Ex.Block(converters.Select((c, i) =>
                                                        Ex.Block(
                                                            Ex.Assign(res[i],
                                                                      c.ApplyTo(Ex.MakeIndex(split, indexer, new[] { Ex.MakeBinary(Et.Add, Ex.Constant(i), Ex.MakeBinary(Et.Subtract, Ex.Property(split, nameof(Array.Length)), Ex.Constant(tupa))) }))),
                                                            Ex.IfThen(Ex.Not(Ex.Property(res[i], nameof(IConversionResult.IsSuccessful))),
                                                                      Ex.Goto(end, NoResult(to))))));
            var block = Ex.Block(new[] { split },
                                 Ex.Assign(split, Ex.Call(input, nameof(string.Split), Type.EmptyTypes, _separator)),
                                 Ex.Condition(Ex.MakeBinary(Et.LessThan, Ex.Property(split, nameof(Array.Length)), Ex.Constant(tupa)),
                                              NoResult(to),
                                              Ex.Block(res,
                                                       Ex.IfThen(Ex.MakeBinary(Et.GreaterThan, Ex.Property(split, nameof(Array.Length)), Ex.Constant(tupa)),
                                                                 Ex.Assign(Ex.ArrayAccess(split, Ex.MakeBinary(Et.Subtract, Ex.Property(split, nameof(Array.Length)), Ex.Constant(tupa))),
                                                                           Ex.Call(typeof(string), nameof(string.Join), Type.EmptyTypes, _separatorString,
                                                                                   Ex.Call(typeof(Enumerable), nameof(Enumerable.Take), new[] { typeof(string) }, split,
                                                                                           Ex.MakeBinary(Et.Add, Ex.Constant(1), Ex.MakeBinary(Et.Subtract, Ex.Property(split, nameof(Array.Length)), Ex.Constant(tupa))))))),
                                                       conversion,
                                                       Ex.Label(end, Result(to, Ex.Call(Creator(to), res.Select(r => Ex.Property(r, nameof(IConversionResult.Result)))))))));
            var lambda = Ex.Lambda(block, input);

            return(lambda);
        }
Beispiel #5
0
        public void If(
            LinqExpr Condition,
            Action True,
            Action False)
        {
            string name = LabelName();

            LinqExprs.LabelTarget _else = LinqExpr.Label("if_" + name + "_else");
            LinqExprs.LabelTarget end   = LinqExpr.Label("if_" + name + "_end");

            // Check the condition, exit if necessary.
            code.Add(LinqExpr.IfThen(LinqExpr.Not(Condition), LinqExpr.Goto(_else)));

            // Execute true code.
            PushScope();
            True();
            PopScope();
            code.Add(LinqExpr.Goto(end));

            // Execute false code.
            code.Add(LinqExpr.Label(_else));
            PushScope();
            False();
            PopScope();

            // Exit point.
            code.Add(LinqExpr.Label(end));
        }
        protected override object VisitFor(For F)
        {
            target.PushScope();

            // Generate the loop header code.
            Visit(F.Init);

            string name = target.LabelName();

            LinqExprs.LabelTarget begin = LinqExpr.Label("for_" + name + "_begin");
            LinqExprs.LabelTarget end   = LinqExpr.Label("for_" + name + "_end");
            loops.Push(new Loop(LinqExpr.Goto(end), LinqExpr.Goto(begin)));

            // Check the condition, exit if necessary.
            target.Add(LinqExpr.Label(begin));
            target.Add(LinqExpr.IfThen(LinqExpr.Not(target.Compile(F.Condition)), LinqExpr.Goto(end)));

            // Generate the body code.
            Visit(F.Body);

            // Generate the step code.
            Visit(F.Step);
            target.Add(LinqExpr.Goto(begin));

            // Exit point.
            target.Add(LinqExpr.Label(end));

            loops.Pop();
            target.PopScope();

            return(null);
        }
Beispiel #7
0
        /// <summary>
        /// Generate a for loop with the given code generator functions.
        /// </summary>
        /// <param name="Init"></param>
        /// <param name="Condition"></param>
        /// <param name="Step"></param>
        /// <param name="Body"></param>
        public void For(
            Action Init,
            LinqExpr Condition,
            Action Step,
            Action <LinqExpr, LinqExpr> Body)
        {
            PushScope();

            // Generate the loop header code.
            Init();

            string name = LabelName();

            LinqExprs.LabelTarget begin = LinqExpr.Label("for_" + name + "_begin");
            LinqExprs.LabelTarget end   = LinqExpr.Label("for_" + name + "_end");

            // Check the condition, exit if necessary.
            code.Add(LinqExpr.Label(begin));
            code.Add(LinqExpr.IfThen(LinqExpr.Not(Condition), LinqExpr.Goto(end)));

            // Generate the body code.
            Body(LinqExpr.Goto(end), LinqExpr.Goto(begin));

            // Generate the step code.
            Step();
            code.Add(LinqExpr.Goto(begin));

            // Exit point.
            code.Add(LinqExpr.Label(end));

            PopScope();
        }
Beispiel #8
0
 public static ExTP LNearestEnemy() => b => {
     var loc = new TExV2();
     return(Ex.Block(new ParameterExpression[] { loc },
                     Ex.IfThen(Ex.Not(Enemy.findNearest.Of(b.loc, loc)),
                               loc.Is(Ex.Constant(new Vector2(0f, 50f)))
                               ),
                     loc
                     ));
 };
Beispiel #9
0
        public static ISpecification <T> Not <T>(this ISpecification <T> specification) where T : class
        {
            var not = Expression.Not(ExtractCondition <T>(specification.Expression).Body);

            var queryable = CreateQueryable <T>().Where(Expression.Lambda <Func <T, bool> >(not, ExtractCondition <T>(specification.Expression).Parameters));

            queryable = AddOrdering(queryable, specification.Expression, false);
            queryable = AddPaging(queryable, specification.Expression, false);

            return(new Specification <T>(queryable.Expression));
        }
Beispiel #10
0
 private static Ex enumeratorConversion(Type to, Ex enumerator, Type eType, LambdaExpression[] converters, Ex[] res, System.Linq.Expressions.LabelTarget end)
 {
     return(Ex.Block(res.Zip(converters, (r, con) =>
                             Ex.Block(
                                 Ex.IfThenElse(
                                     enumerator.Type.GetTypeInfo().GetDeclaredMethod(nameof(IEnumerator.MoveNext)) == null
                         ? Ex.Call(Ex.Convert(enumerator, typeof(IEnumerator)), nameof(IEnumerator.MoveNext), Type.EmptyTypes)
                         : Ex.Call(enumerator, enumerator.Type.GetTypeInfo().GetDeclaredMethod(nameof(IEnumerator.MoveNext))),
                                     Ex.Assign(r, con.ApplyTo(Ex.Property(enumerator, nameof(IEnumerator.Current)))),
                                     Ex.Goto(end, NoResult(to))),
                                 Ex.IfThen(Ex.Not(Ex.Property(r, nameof(IConversionResult.IsSuccessful))),
                                           Ex.Goto(end, NoResult(to)))))));
 }
Beispiel #11
0
        public static Ex DictSafeGet(this Ex dict, Ex key, string err)
        {
            return(Ex.Block(
                       Ex.IfThen(Ex.Not(ExUtils.DictContains(dict, key)), Ex.Throw(Ex.Constant(new Exception(err)))),
                       dict.DictGet(key)
                       ));

            /*
             * return Ex.Condition(ExUtils.DictContains<K, V>(dict, key), dict.DictGet(key), Ex.Block(
             *  Ex.Throw(Ex.Constant(new Exception(err))),
             *  dict.DictGet(key)
             * ));*/
        }
        private UnaryExpression UnaryExpression(
            ExpressionType nodeType, System.Type type, JObject obj)
        {
            var operand = this.Prop(obj, "operand", this.Expression);
            var method  = this.Prop(obj, "method", this.Method);

            switch (nodeType)
            {
            case ExpressionType.ArrayLength: return(Expr.ArrayLength(operand));

            case ExpressionType.Convert: return(Expr.Convert(operand, type, method));

            case ExpressionType.ConvertChecked: return(Expr.ConvertChecked(operand, type, method));

            case ExpressionType.Decrement: return(Expr.Decrement(operand, method));

            case ExpressionType.Increment: return(Expr.Increment(operand, method));

            case ExpressionType.IsFalse: return(Expr.IsFalse(operand, method));

            case ExpressionType.IsTrue: return(Expr.IsTrue(operand, method));

            case ExpressionType.Negate: return(Expr.Negate(operand, method));

            case ExpressionType.NegateChecked: return(Expr.NegateChecked(operand, method));

            case ExpressionType.Not: return(Expr.Not(operand, method));

            case ExpressionType.OnesComplement: return(Expr.OnesComplement(operand, method));

            case ExpressionType.PostDecrementAssign: return(Expr.PostDecrementAssign(operand, method));

            case ExpressionType.PostIncrementAssign: return(Expr.PostIncrementAssign(operand, method));

            case ExpressionType.PreDecrementAssign: return(Expr.PreDecrementAssign(operand, method));

            case ExpressionType.PreIncrementAssign: return(Expr.PreIncrementAssign(operand, method));

            case ExpressionType.Quote: return(Expr.Quote(operand));

            case ExpressionType.Throw: return(Expr.Throw(operand, type));

            case ExpressionType.TypeAs: return(Expr.TypeAs(operand, type));

            case ExpressionType.UnaryPlus: return(Expr.UnaryPlus(operand, method));

            case ExpressionType.Unbox: return(Expr.Unbox(operand, type));

            default: throw new NotSupportedException();
            }
        }
        private LambdaExpression constructionLambda(Type from, Type to)
        {
            var valueType = recordCreator.GetValueType(from);
            var recType   = typeof(IRecord <>).MakeGenericType(valueType);
            var tryGet    = recType.GetTypeInfo().GetDeclaredMethod(nameof(IRecord <object> .TryGetValue));

            var input = Ex.Parameter(from, "input");
            var rec   = Ex.Parameter(recType, "rec");
            var ctor  = GetConstructorForType(to);
            var tmp   = Ex.Parameter(valueType, "tmp");
            var pars  = ctor.GetParameters().Select((p, i) => new
            {
                Converter = Ref.GetLambda(valueType, p.ParameterType),
                Var       = Ex.Parameter(typeof(ConversionResult <>).MakeGenericType(p.ParameterType), p.Name),
                Type      = p.ParameterType,
                Optional  = p.GetCustomAttributes <OptionalAttribute>().Any(),
                Default   = p.HasDefaultValue ? p.DefaultValue : p.ParameterType.GetTypeInfo().IsValueType ? Activator.CreateInstance(p.ParameterType) : null
            }).ToArray();
            var end   = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to), "end");
            var block = Ex.Block(new[] { rec }.Concat(pars.Select(x => x.Var)),
                                 Ex.Assign(rec, recordCreator.Creator(from).ApplyTo(input)),
                                 Ex.Block(new[] { tmp }, pars
                                          .Select(x =>
                                                  x.Optional
                        ? Ex.Block(
                                                      Ex.IfThenElse(
                                                          Ex.MakeBinary(ExpressionType.OrElse,
                                                                        Ex.Call(rec, tryGet, Ex.Constant(x.Var.Name), tmp),
                                                                        Ex.Call(rec, tryGet, Ex.Constant(ToPascalCase(x.Var.Name)), tmp)),
                                                          Ex.Block(
                                                              Ex.Assign(x.Var, x.Converter.ApplyTo(tmp)),
                                                              Ex.IfThen(Ex.Not(Ex.Property(x.Var, nameof(IConversionResult.IsSuccessful))),
                                                                        Ex.Goto(end, NoResult(to)))),
                                                          Ex.Assign(x.Var, Result(x.Type, Ex.Constant(x.Default, x.Type)))))
                        : Ex.Block(
                                                      Ex.IfThen(Ex.Not(Ex.Call(rec, tryGet, Ex.Constant(x.Var.Name), tmp)),
                                                                Ex.IfThen(Ex.Not(Ex.Call(rec, tryGet, Ex.Constant(ToPascalCase(x.Var.Name)), tmp)),
                                                                          Ex.Goto(end, NoResult(to)))),
                                                      Ex.Assign(x.Var, x.Converter.ApplyTo(tmp)),
                                                      Ex.IfThen(Ex.Not(Ex.Property(x.Var, nameof(IConversionResult.IsSuccessful))),
                                                                Ex.Goto(end, NoResult(to)))))),
                                 Ex.Label(end, Result(to, Ex.New(ctor, pars.Select(p => Ex.Property(p.Var, nameof(IConversionResult.Result)))))));

            return(Ex.Lambda(block, input));
        }
Beispiel #14
0
        private LambdaExpression createForList(Type from, Type to)
        {
            var cType = (from i in @from.GetTypeInfo().ImplementedInterfaces.Concat(new[] { @from })
                         where i.GetTypeInfo().IsInterface &&
                         i.GenericTypeArguments.Length == 1 &&
                         i.GetGenericTypeDefinition() == typeof(IReadOnlyList <>)
                         select i.GenericTypeArguments[0]).SingleOrDefault();

            if (cType == null)
            {
                return(null);
            }
            var indexer      = typeof(IReadOnlyList <>).MakeGenericType(cType).GetTypeInfo().GetDeclaredProperty("Item");
            var count        = typeof(IReadOnlyCollection <>).MakeGenericType(cType).GetTypeInfo().GetDeclaredProperty(nameof(IReadOnlyCollection <object> .Count));
            var toParameters = to.GetTypeInfo().GenericTypeArguments;
            var input        = Ex.Parameter(from, "input");
            var converters   = toParameters.Select(p => Ref.GetLambda(cType, p)).ToArray();
            var res          = toParameters.Select(p => Ex.Parameter(typeof(ConversionResult <>).MakeGenericType(p))).ToArray();
            var end          = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to), "end");

            var conversion = Ex.Block(converters.Select((c, i) =>
                                                        Ex.Block(
                                                            Ex.Assign(res[i],
                                                                      c.ApplyTo(Ex.MakeIndex(input, indexer, new[] { Ex.Constant(i) }))),
                                                            Ex.IfThen(Ex.Not(Ex.Property(res[i], nameof(IConversionResult.IsSuccessful))),
                                                                      Ex.Goto(end, NoResult(to))))));
            var block = Ex.Block(res,
                                 Ex.IfThen(
                                     Ex.MakeBinary(Et.LessThan,
                                                   Ex.Property(input, count),
                                                   Ex.Constant(toParameters.Length)),
                                     Ex.Goto(end, NoResult(to))),
                                 conversion,
                                 Ex.Label(end, Result(to, Ex.Call(Creator(to), res.Select(r => Ex.Property(r, nameof(IConversionResult.Result)))))));
            var lambda = Ex.Lambda(block, input);

            return(lambda);
        }
Beispiel #15
0
        private Exp MakeUnary(CompilerState state, Node node)
        {
            if (state == null)
            {
                throw new Exception();
            }
            if (node == null)
            {
                throw new Exception();
            }

            var data = node.Token.Data as Tokenizing.OperatorData;

            if (data == null)
            {
                throw new Exception();
            }

            if (node.Children.Count != 1)
            {
                throw new Exception();
            }

            if (data.Operator == Operator.Minus)
            {
                var value = Make(state, node.Children[0]);
                return(Exp.Negate(value));
            }

            if (data.Operator == Operator.LogicalNot)
            {
                var value = Make(state, node.Children[0]);
                return(Exp.Not(ToBoolean(value)));
            }

            throw new Exception();
        }
        public LambdaExpression CreateLambda(Type from, Type to)
        {
            var input          = Ex.Parameter(from, "input");
            var eType          = to.GetElementType();
            var res            = Ex.Parameter(typeof(ConversionResult <>).MakeGenericType(eType).MakeArrayType(), "res");
            var end            = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to), "end");
            var fromParameters = from.GetTypeInfo().GenericTypeArguments;
            var converters     = fromParameters.Select(t => new { Lambda = Ref.GetLambda(t, eType), Input = t }).ToArray();

            var block = Ex.Block(new[] { res },
                                 Ex.Assign(res, Ex.NewArrayBounds(typeof(ConversionResult <>).MakeGenericType(eType), Ex.Constant(fromParameters.Length))),
                                 Ex.Block(converters.Select((con, i) =>
                                                            Ex.Block(
                                                                Ex.Assign(Ex.ArrayAccess(res, Ex.Constant(i)), con.Lambda.ApplyTo(Ex.PropertyOrField(input, $"Item{i + 1}"))),
                                                                Ex.IfThen(Ex.Not(Ex.Property(Ex.ArrayIndex(res, Ex.Constant(i)), nameof(IConversionResult.IsSuccessful))),
                                                                          Ex.Goto(end, NoResult(to)))))),
                                 Ex.Label(end, Result(to,
                                                      Ex.NewArrayInit(eType,
                                                                      Enumerable.Range(0, fromParameters.Length)
                                                                      .Select(idx => Ex.Property(Ex.ArrayIndex(res, Ex.Constant(idx)), nameof(IConversionResult.Result)))))));
            var lambda = Ex.Lambda(block, input);

            return(lambda);
        }
Beispiel #17
0
        /// <summary>
        /// Negates the predicate.
        /// </summary>
        public static Expression <Func <T, bool> > Not <T>(this Expression <Func <T, bool> > expression)
        {
            var negated = Expression.Not(expression.Body);

            return(Expression.Lambda <Func <T, bool> >(negated, expression.Parameters));
        }
Beispiel #18
0
        /// <summary>
        ///     Creates <see cref="ICriterion" /> for a comparison between a value and a projection.
        /// </summary>
        /// <param name="expression">
        ///     The expression.
        /// </param>
        /// <param name="value">
        ///     The value.
        /// </param>
        /// <param name="type">
        ///     The comparison type.
        /// </param>
        /// <param name="context">
        ///     The helper context.
        /// </param>
        /// <param name="overTurned">
        ///     Indicates whether the comparison has been reversed to simplify other code.
        /// </param>
        /// <returns>
        ///     The created <see cref="ICriterion" />.
        /// </returns>
        /// <exception cref="NotSupportedException">
        ///     The <see cref="Expression" /> could not be resolved as it may contain unsupported features or similar.
        /// </exception>
        public static ICriterion GetProjectionValueCriterion
        (
            Expression expression,
            object value,
            ExpressionType type,
            HelperContext context,
            bool overTurned
        )
        {
            if (overTurned)
            {
                switch (type)
                {
                case ExpressionType.GreaterThan:
                    type = ExpressionType.LessThan;
                    break;

                case ExpressionType.GreaterThanOrEqual:
                    type = ExpressionType.LessThanOrEqual;
                    break;

                case ExpressionType.LessThan:
                    type = ExpressionType.GreaterThan;
                    break;

                case ExpressionType.LessThanOrEqual:
                    type = ExpressionType.GreaterThanOrEqual;
                    break;
                }
            }

            IProjection projection = ProjectionHelper.GetProjection(expression, context);

            switch (type)
            {
            case ExpressionType.Equal:

                if (value == null)
                {
                    return(Restrictions.IsNull(projection));
                }

                if (value is bool)
                {
                    return(GetCriterion((bool)value ? expression : Expression.Not(expression), context));
                }

                return(Restrictions.Eq(projection, value));

            case ExpressionType.NotEqual:

                if (value == null)
                {
                    return(Restrictions.IsNotNull(projection));
                }

                if (value is bool)
                {
                    return(GetCriterion(!(bool)value ? expression : Expression.Not(expression), context));
                }

                return(Restrictions.Not(Restrictions.Eq(projection, value)));

            case ExpressionType.GreaterThan:
                return(Restrictions.Gt(projection, value));

            case ExpressionType.GreaterThanOrEqual:
                return(Restrictions.Ge(projection, value));

            case ExpressionType.LessThan:
                return(Restrictions.Lt(projection, value));

            case ExpressionType.LessThanOrEqual:
                return(Restrictions.Le(projection, value));

            default:
                throw new NotSupportedException
                      (
                          "the expression contains unsupported features, please revise your code"
                      );
            }
        }
Beispiel #19
0
 public static Expression Not(Expression arg)
 {
     return(new Expression(LinqExpression.Not(arg)));
 }
Beispiel #20
0
            private static UnaryExpression NotContainsExpression(ParameterExpression parameter, string propertyName, object value)
            {
                var expression = ContainsExpression(parameter, propertyName, value);

                return(SystemExpression.Not(expression));
            }
Beispiel #21
0
 /// <summary>
 ///
 /// </summary>
 /// <returns></returns>
 protected override Expression <Func <TEntity, bool> > CreateExpression()
 {
     return(Expression_.Lambda <Func <TEntity, bool> >(Expression_.Not(_OriginalCriteria.Body),
                                                       _OriginalCriteria.Parameters.Single()));
 }