internal static Expression[] GenTypedArgs(GenContext context, ParameterInfo[] parms, IPersistentVector args) { Expression[] exprs = new Expression[parms.Length]; for (int i = 0; i < parms.Length; i++) exprs[i] = GenTypedArg(context,parms[i].ParameterType, (Expr)args.nth(i)); return exprs; }
public override Expression GenDlr(GenContext context) { Expression fn = _fexpr.GenDlr(context); fn = Expression.Convert(fn, typeof(IFn)); int argCount = _args.count(); Expression[] args = new Expression[argCount]; for (int i = 0; i < argCount; i++ ) args[i] = Compiler.MaybeBox(((Expr)_args.nth(i)).GenDlr(context)); Expression call = GenerateInvocation(fn, args); return call; }
private Expression GenDlrViaReflection(GenContext context) { Expression[] parms = new Expression[_args.count()]; for ( int i=0; i<_args.count(); i++ ) parms[i] = Compiler.MaybeBox(((Expr)_args.nth(i)).GenDlr(context)); Expression[] moreArgs = new Expression[3]; moreArgs[0] = Expression.Constant(_methodName); moreArgs[1] = Expression.Constant(_type); moreArgs[2] = Expression.NewArrayInit(typeof(object), parms); return Expression.Call(Compiler.Method_Reflector_CallStaticMethod, moreArgs); }
private static Expression GenerateInvocation(Type returnType, Expression fn, Expression[] args) { MethodInfo mi; Expression[] actualArgs; if (args.Length <= Compiler.MAX_POSITIONAL_ARITY) { mi = Compiler.Methods_IFn_invoke[args.Length]; actualArgs = args; } else { // pick up the extended version. mi = Compiler.Methods_IFn_invoke[Compiler.MAX_POSITIONAL_ARITY + 1]; Expression[] leftoverArgs = new Expression[args.Length - Compiler.MAX_POSITIONAL_ARITY]; Array.ConstrainedCopy(args, Compiler.MAX_POSITIONAL_ARITY, leftoverArgs, 0, args.Length - Compiler.MAX_POSITIONAL_ARITY); Expression restArg = Expression.NewArrayInit(typeof(object), leftoverArgs); actualArgs = new Expression[Compiler.MAX_POSITIONAL_ARITY + 1]; Array.ConstrainedCopy(args, 0, actualArgs, 0, Compiler.MAX_POSITIONAL_ARITY); actualArgs[Compiler.MAX_POSITIONAL_ARITY] = restArg; } Expression call = Expression.Call(fn, mi, actualArgs); // Java version doesn't seem to do this. Instead, its InvokeExpression carries the type information so someone else can use it. // Not sure if this is useful here. if (returnType != null) call = Expression.Convert(call, returnType); return call; }
private static Expression GenerateInvocation(Expression fn, Expression[] args) { MethodInfo mi; Expression[] actualArgs; if (args.Length <= Compiler.MAX_POSITIONAL_ARITY) { mi = Compiler.Methods_IFn_invoke[args.Length]; actualArgs = args; } else { // pick up the extended version. mi = Compiler.Methods_IFn_invoke[Compiler.MAX_POSITIONAL_ARITY + 1]; Expression[] leftoverArgs = new Expression[args.Length - Compiler.MAX_POSITIONAL_ARITY]; Array.Copy(args, Compiler.MAX_POSITIONAL_ARITY, leftoverArgs, 0, args.Length - Compiler.MAX_POSITIONAL_ARITY); Expression restArg = Expression.NewArrayInit(typeof(object), leftoverArgs); actualArgs = new Expression[Compiler.MAX_POSITIONAL_ARITY + 1]; Array.Copy(args, 0, actualArgs, 0, Compiler.MAX_POSITIONAL_ARITY); actualArgs[Compiler.MAX_POSITIONAL_ARITY] = restArg; } Expression call = Expression.Call(fn, mi, actualArgs); return call; }
internal static Expression MaybeBox(Expression expr) { if (expr.Type == typeof(void)) // I guess we'll pass a void. This happens when we have a throw, for example. return Expression.Block(expr, Expression.Default(typeof(object))); return expr.Type.IsValueType ? Expression.Convert(expr, typeof(object)) : expr; }
internal static Expression[] GenTypedArgArray(GenContext context, ParameterInfo[] infos, IPersistentVector args) { Expression[] exprs = new Expression[args.count()]; for (int i = 0; i < infos.Length; i++) { Expr e = (Expr)args.nth(i); // Java: this is in a try/catch, where the catch prints a stack trace if (MaybePrimitiveType(e) == infos[i].ParameterType) exprs[i] = ((MaybePrimitiveExpr)e).GenDlrUnboxed(context); else // Java follows this with: HostExpr.emitUnboxArg(fn, gen, parameterTypes[i]); //exprs[i] = e.GenDlr(context); exprs[i] = Expression.Convert(e.GenDlr(context), infos[i].ParameterType); ; } return exprs; }
internal static Expression GenArgArray(GenContext context, IPersistentVector args) { Expression[] exprs = new Expression[args.count()]; for (int i = 0; i < args.count(); i++) { Expr arg = (Expr)args.nth(i); exprs[i] = Compiler.MaybeBox(arg.GenDlr(context)); } Expression argArray = Expression.NewArrayInit(typeof(object), exprs); return argArray; }
static Expression[] MaybeBox(Expression[] args) { // TODO: avoid copying array if not necessary Expression[] boxedArgs = new Expression[args.Length]; for (int i1 = 0; i1 < args.Length; ++i1) boxedArgs[i1] = MaybeBox(args[i1]); return boxedArgs; }