C# Scope.GetRuntime方法代码示例

        private static Expression CompileObj(Obj obj, Scope scope)
        {
            var temp = scope.FreeVariable("obj");
            var expressions = new List<Expression>
            {
                Expression.Assign(temp, Expression.New(ExpandoConstructor))
            };

            foreach (var @base in obj.Properties)
            {
                var property = @base as Assign;

                foreach (var name in CompileToNames(property.Variable))
                {
                    var expression = Compile(property.Value, scope);

                    expressions.Add(Expression.Dynamic(scope.GetRuntime().SetMemberBinders.Get(name), typeof(object), temp, expression));
                }
            }

            expressions.Add(temp);

            return Expression.Block(expressions);
        }

        public static Expression CompileValue(Value node, Scope scope)
        {
            var curExpr = Compile(node.Base, scope);

            foreach (var name in CompileToNames(node.Properties))
            {
                curExpr = Expression.Dynamic(scope.GetRuntime().GetMemberBinders.Get(name),
                    typeof (object),
                    curExpr
                );
            }

            Helper.IsNotNull(curExpr);

            return curExpr;
        }

        public static Expression CompileOp(Op op, Scope scope)
        {
            var ischain = op.IsChainable && op.First is Op && ((Op)op.First).IsChainable;

            if (op.Second == null)
                return CompileUnary(op, scope);

            if (ischain)
                return CompileChain(op, scope);

            if (op.Operator == "?")
                return CompileExistence(op, scope);

            var first = Compile(op.First, scope);
            var second = Compile(op.Second, scope);

            var operation = GetExpressionType(op.Operator);
            return Expression.Dynamic(
                scope.GetRuntime().BinaryOperationBinders.Get(operation),
                typeof(object),
                first,
                second
            );
        }

        public static Expression CompileChain(Op op, Scope scope)
        {
            //for a chain we need to convert the second param of the first to a local. then we can do two comparisons and merge them with &&
            var first = op.First as Op;

            var refName = scope.FreeVariableName("ref");

            first.Second = first.Second.Cache(refName);

            var fst = Compile(first, scope);
            var scd = Compile(new Op {First = first.Second, Second = op.Second, Operator = op.Operator}, scope);

            return Expression.Dynamic(
                scope.GetRuntime().BinaryOperationBinders.Get(ExpressionType.And),
                typeof (object),
                fst, scd);
        }

        public static Expression CompileCall(Call node, Scope scope)
        {
            var args = new List<Expression>();
            args.AddRange(node.Arguments.Select(arg => Compile(arg, scope)));

            return GetMemberInvocaton(node.Variable, scope,
                (memberObject, name) =>
                {
                    args.Insert(0, memberObject);
                    return Expression.Dynamic(scope.GetRuntime().InvokeMemberBinders.Get(new InvokeMemberBinderKey(name, new CallInfo(node.Arguments.Count))), typeof(object), args);
                },
                (memberObject) =>
                {
                    args.Insert(0, memberObject);
                    return Expression.Dynamic(scope.GetRuntime().InvokeBinders.Get(new CallInfo(node.Arguments.Count)), typeof (object), args);
                });
        }

        public static Expression CompileAssign(Assign node, Scope scope)
        {
            var variable = node.Variable as Value;
            var value = node.Value;

            if (variable != null)
            {
                if (variable.IsObject)
                {
                    var obj = variable.Base as Obj;
                    return CompileObjectAssignment(obj, value, scope);
                }

                if (!node.Variable.IsAssignable)
                    throw new InvalidOperationException("Variable is not assignable");
                if (!variable.HasProperties)
                {
                    foreach(var name in CompileToNames(variable))
                        scope.Add(name, VariableType.Variable);
                }
            }

            var right = Compile(value, scope);

            return GetMemberInvocaton(node.Variable, scope,
                        (memberObject, name) => Expression.Dynamic(scope.GetRuntime().SetMemberBinders.Get(name), typeof (object), memberObject, right),
                        (memberObject) => Expression.Assign(memberObject, right));
        }