Exemple #1
0
        public ParameterDef(Symbol sym, object specializer   = null,
                            Expression initForm              = null,
                            Func <object> initFormProc       = null,
                            LambdaSignature nestedParameters = null,
                            bool hidden = false)
        {
            Sym              = sym;
            Specializer      = specializer;
            NestedParameters = nestedParameters;
            InitForm         = initForm;
            InitFormProc     = initFormProc;
            Hidden           = hidden;

            if (InitForm != null && InitFormProc == null)
            {
                InitFormProc = Runtime.CompileToFunction(initForm);
            }
        }
Exemple #2
0
        object IApply.Apply(object[] args)
        {
            if (args.Length > 12)
            {
                var binder = Runtime.GetInvokeBinder(args.Length);
                var exprs  = new List <Expression>();
                exprs.Add(Expression.Constant(this));
                exprs.AddRange(args.Select(Expression.Constant));
                var code = Runtime.CompileDynamicExpression(binder, typeof(object), exprs);
                var proc = Runtime.CompileToFunction(code);
                return(proc());
            }
            else
            {
                switch (args.Length)
                {
                case 0:
                {
                    return(Proc0());
                }

                case 1:
                {
                    return(Proc1(args[0]));
                }

                case 2:
                {
                    return(Proc2(args[0], args[1]));
                }

                case 3:
                {
                    return(Proc3(args[0], args[1], args[2]));
                }

                case 4:
                {
                    return(Proc4(args[0], args[1], args[2], args[3]));
                }

                case 5:
                {
                    return(Proc5(args[0], args[1], args[2], args[3], args[4]));
                }

                case 6:
                {
                    return(Proc6(args[0], args[1], args[2], args[3], args[4], args[5]));
                }

                case 7:
                {
                    return(Proc7(args[0], args[1], args[2], args[3], args[4], args[5], args[6]));
                }

                case 8:
                {
                    return(Proc8(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]));
                }

                case 9:
                {
                    return(Proc9(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]));
                }

                case 10:
                {
                    return(Proc9(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9]));
                }

                case 11:
                {
                    return(Proc9(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10]));
                }

                case 12:
                {
                    return(Proc9(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11]));
                }

                default:
                {
                    throw new NotImplementedException("Apply supports up to 12 arguments");
                }
                }
            }
        }
Exemple #3
0
        object IApply.Apply(object[] args)
        {
            if (args.Length > 6)
            {
                var args2 = args.Select(x => (Expression)Expression.Constant(x)).ToArray();
                var expr  = AccessorLambdaMetaObject.MakeExpression(Nullable, Members, args2);
                var proc  = Runtime.CompileToFunction(expr);
                var val   = proc();
                return(val);
            }
            else
            {
                switch (args.Length)
                {
                case 0:
                {
                    if (Proc0 == null)
                    {
                        Proc0 = (Func <object>)MakeExpressionProc(0);
                    }
                    return(Proc0());
                }

                case 1:
                {
                    if (Proc1 == null)
                    {
                        Proc1 = (Func <object, object>)MakeExpressionProc(1);
                    }
                    return(Proc1(args[0]));
                }

                case 2:
                {
                    if (Proc2 == null)
                    {
                        Proc2 = (Func <object, object, object>)MakeExpressionProc(2);
                    }
                    return(Proc2(args[0], args[1]));
                }

                case 3:
                {
                    if (Proc3 == null)
                    {
                        Proc3 = (Func <object, object, object, object>)MakeExpressionProc(3);
                    }
                    return(Proc3(args[0], args[1], args[2]));
                }

                case 4:
                {
                    if (Proc4 == null)
                    {
                        Proc4 = (Func <object, object, object, object, object>)MakeExpressionProc(4);
                    }
                    return(Proc4(args[0], args[1], args[2], args[3]));
                }

                case 5:
                {
                    if (Proc5 == null)
                    {
                        Proc5 = (Func <object, object, object, object, object, object>)MakeExpressionProc(1);
                    }
                    return(Proc5(args[0], args[1], args[2], args[3], args[4]));
                }

                case 6:
                {
                    if (Proc6 == null)
                    {
                        Proc6 = (Func <object, object, object, object, object, object, object>)MakeExpressionProc(6);
                    }
                    return(Proc6(args[0], args[1], args[2], args[3], args[4], args[5]));
                }

                default:
                {
                    throw new NotImplementedException("Apply supports up to 6 arguments");
                }
                }
            }
        }